Production Rust Systems, Demonstrated Live

• Cookiesession_id · http-only
• Session storepostgres + SQLx
• Auth hashdedicated session hash
• Lifecycleexpiry + cleanup task

Identity and Session Durability

Encrypted cookies and durable Postgres-backed sessions keep identity consistent across requests.

• axum-login provider + tower-sessions for auth state
• Session cookie is signed/encrypted and HTTP-only
• Credential hashing is isolated behind app traits
• Tracing attaches user/session context to requests

Built withaxum-logintower-sessionspostgres

• HTTPsignals -> request DTO
• AppPostMessage command
• DomainRoomId, MessageBody, UserId
• Infrarepo + SQL + audit

Boundary-Safe Request Flow

Transport, policy, domain invariants, and persistence stay separated by typed handoffs.

• HTTP DTOs parse untrusted input
• App commands orchestrate use-case policy
• Domain newtypes enforce invariants
• Infra owns SQL rows and concrete mechanisms

Cratesdomainappinfrahttp

• request endstatus + latency + route
• chat incomingsender + payload_bytes
• chat broadcastselector=[data-chat-messages]
• network panelSSE + HTTP tables

Observability and Real-Time Delivery

Request spans, live logs, and SSE patches make behavior inspectable while the app runs.

• Live and diagnostic streams are intentionally separated
• Network log shows status/method/path/latency
• SSE events track selector/mode/payload bytes
• Trace fields include request/session/user context

Signalstracingssedatastarlog panels

• RequestPOST /demo/chat/messages
• Validationtyped ids + message body
• Persistencechat_messages + audit
• Fanoutappend [data-chat-messages]

Live Chat Capstone

A complete request -> validate -> persist -> broadcast path with moderation and rate limiting.

• Messages persist to Postgres and reload on entry
• Rate limits and moderation are enforced in app services
• SSE pushes append updates to all connected tabs
• Moderation queue surfaces pending decisions

Includespersistencerate limitmoderationsse fanout

Boundary-first modeling

App defines contracts and infra implements mechanisms, so policy stays stable as storage evolves.

• Core policy flows are insulated from transport and SQL details.
• Repository traits in app enforce dependency direction.
• Domain entities avoid HTTP/database concerns.

Scopedomainappinfrahttp

Example: crates/app/src/chat/mod.rs

pub trait ChatRepository: Send + Sync {
    async fn create_room(
        &self,
        name: room::RoomName,
        created_by: room::UserId,
    ) -> Result<room::Room>;
}

Typed invariants over stringly logic

Enums and newtypes move correctness checks to compile time and reduce typo-prone runtime branching.

• Serialization values are mapped via enum variants.
• State transitions stay explicit and searchable.
• Invalid states are unrepresentable in regular paths.

Patternenumnewtypestrum

Example: crates/domain/src/chat/message.rs

#[derive(Debug, Clone, Copy, PartialEq, Eq, strum_macros::Display, strum_macros::EnumString)]
pub enum MessageStatus {
    #[strum(serialize = "visible")]
    Visible,
    #[strum(serialize = "pending")]
    Pending,
    #[strum(serialize = "removed")]
    Removed,
}

Centralized error contracts

Handlers stay focused on workflow while response behavior remains consistent across pages and partials.

• A single HTTP error type maps app/domain failures.
• Datastar vs full-page behavior stays consistent.
• Cross-cutting response behavior is easier to review.

Outcomeconsistencyclaritysafety

Example: crates/http/src/error.rs

pub enum Error {
    Internal,
    Unauthorized,
    Validation(Text),
    Chat(app::chat::Error),
    User(app::user::Error),
    Auth(app::auth::Error),
}

Observability designed as architecture

Live and diagnostic streams are intentionally separated so users see signal instead of noise.

• Known target enums enforce naming discipline.
• Request context fields are added consistently.
• Live panel remains concise while diagnostic depth stays available.

Built ontracingSSEtyped targets

Example: crates/http/src/trace_log.rs

#[derive(Clone, Copy, Debug, PartialEq, Eq, Display, EnumString)]
pub enum LogTargetKnown {
    #[strum(serialize = "demo.request")]
    DemoRequest,
    #[strum(serialize = "demo.db")]
    DemoDb,
    #[strum(serialize = "demo.sse")]
    DemoSse,
    #[strum(serialize = "http::router::layers")]
    RouterLayers,
}

Reusable view components with typed inputs

Shared typed components reduce duplication and make broad UI changes local and safe.

• View models are explicit and composable.
• Large pages stay readable by composing `Render` partials.
• UI iteration happens without touching transport logic.

Techniquemaud::Renderbuildertyped props

Example: crates/http/src/views/partials/demo/log/row.rs

#[derive(Clone, Debug, Builder)]
pub struct Row {
    pub timestamp: Text,
    pub message: Text,
    #[builder(default)]
    pub pills: Vec<Pill>,
}

Builders as readable wiring

Builder pipelines make dependency wiring self-documenting and less error-prone over time.

• Composition roots read as intent rather than boilerplate.
• Constructor growth stays manageable.
• Naming at the callsite clarifies ownership boundaries.

Outcomereadabilitymaintainabilityexplicit wiring

Example: crates/http/src/state.rs

#[builder]
pub fn from_parts(
    #[builder(setters(name = with_user))] user: app::user::Service,
    #[builder(setters(name = with_auth))] auth: app::auth::ProviderImpl,
    #[builder(setters(name = with_chat))] chat: app::chat::Service,
    #[builder(setters(name = with_sse))] sse: crate::sse::Registry,
) -> Self