Crate revelation_user 

revelation-user

A professional user domain crate for the Revelation ecosystem.

This crate provides a complete user management solution with:

• Type-safe user entity with builder pattern
• Multiple authentication methods (Telegram, email, phone)
• Framework-agnostic extractors for axum and actix-web
• Extensible architecture for application-specific user types

Quick Start

Add to your Cargo.toml:

[dependencies]
revelation-user = { version = "0.1", features = ["axum"] }

Create users with the fluent builder API:

use revelation_user::RUser;

// From Telegram authentication
let user = RUser::from_telegram(123456789);

// From email authentication
let user = RUser::from_email("john@example.com");

Features

Feature	Description
db	Database support via sqlx (PostgreSQL)
api	OpenAPI schema generation via utoipa
axum	Axum framework extractors
actix	Actix-web framework extractors

Note: axum and actix features are mutually exclusive.

Core Types

Entity

• RUser - The core user entity with all fields
• Claims - JWT claims for authentication

Projections

Projections are read-only views optimized for specific contexts:

• RUserPublic - Safe for API responses (excludes sensitive data)
• RUserAuth - For JWT/session context (includes role)

use revelation_user::{RUser, RUserAuth, RUserPublic, RUserRole};

let user = RUser::from_telegram(123456789);

// Convert to public view (safe for API)
let public: RUserPublic = user.clone().into();

// Convert to auth view (for JWT)
let auth = RUserAuth::from_user(&user, RUserRole::User);

DTOs

Request/response data transfer objects:

• CreateUserRequest - Create new user
• UpdateProfileRequest - Update user profile
• BindTelegram, BindEmail, BindPhone - Bind contact methods

Extending Users

Use the extend_user! macro to create application-specific user types:

use revelation_user::{extend_user, RUser};
use uuid::Uuid;

extend_user! {
    /// Corporate user with company-specific fields.
    pub struct CorpUser {
        pub company_id: Uuid,

        #[builder(into)]
        pub department: String,
    }
}

// Use with fluent API
let user = CorpUser::from_telegram(123456789)
    .name("John")
    .then()
    .company_id(Uuid::now_v7())
    .department("Engineering")
    .build();

// Access fields transparently via Deref
assert!(user.telegram_id.is_some());  // RUser field

Framework Integration

Axum

use axum::{Router, Json, routing::get};
use revelation_user::{Claims, RUserPublic};

async fn me(claims: Claims) -> Json<RUserPublic> {
    // Claims extracted from JWT cookie or Authorization header
    todo!()
}

let app = Router::new().route("/me", get(me));

Actix-web

use actix_web::{web, HttpResponse};
use revelation_user::{Claims, RUserPublic};

async fn me(claims: Claims) -> HttpResponse {
    // Claims extracted automatically
    HttpResponse::Ok().json(claims.user_id())
}

Validation

All DTOs support validation via the validator crate:

use revelation_user::UpdateProfileRequest;
use validator::Validate;

let req = UpdateProfileRequest {
    name:          Some("J".into()), // Too short!
    gender:        None,
    birth_date:    None,
    confession_id: None
};

assert!(req.validate().is_err());

Module Structure

• entity - Core user entity and JWT claims
• projections - Read-only user views
• dto - Request/response data transfer objects
• extend - Extension macro for custom user types
• [extract] - Framework extractors (feature-gated)
• ports - Repository trait definitions

Re-exports

pub use dto::*;

pub use entity::*;

pub use projections::*;

Modules

dto

Data Transfer Objects for API operations.

entity

Core domain entities for user management.

extend

Extension utilities for creating derived user types.

ports

Port traits for infrastructure layer.

projections

User projections for different contexts.

Macros

extend_user

Creates an extended user type with custom fields.

Structs

Permissions

Bitflag-based permissions for fine-grained access control.

TelegramRecipient

Telegram notification recipient.

Enums

Gender

User’s biological gender.

RUserRole

User role for authorization decisions.

Statics

PHONE_REGEX

E.164 international phone number format regex.

Traits

Role

Trait for types that represent a role with permissions.