Domain Web

by actionbook5c40d3ad7851No license1.5K starsListed Oct 8, 2026Updated Oct 8, 2026Repository updated 6 weeks ago

Use when building web services. Keywords: web server, HTTP, REST API, GraphQL, WebSocket, axum, actix, warp, rocket, tower, hyper, reqwest, middleware, router, handler, extractor, state management, authentication, authorization, JWT, session, cookie, CORS, rate limiting, web 开发, HTTP 服务, API 设计, 中间件, 路由

Instructions onlySoftware Development

AI-generated overview

Guidance for building Rust web services, covering async handlers, state, middleware, and framework choices.

What it does: This skill provides domain constraints and design guidance for building web services in Rust. It maps web requirements such as stateless HTTP, concurrency, and security to Rust design implications, and compares frameworks like axum, actix-web, warp, and rocket. It also lists key crates and design patterns, including an axum handler example with error handling.
When to use it: Use it when building or designing Rust web services, HTTP servers, or REST and GraphQL APIs. It is relevant when choosing a Rust web framework or working with middleware, extractors, shared state, authentication, or request validation.
Requirements: No scripts or special tooling are required; it is instructions only. The guidance assumes Rust web development with crates such as axum, actix-web, reqwest, serde_json, jsonwebtoken, tower-sessions, sqlx, and diesel.

Web Domain

Layer 3: Domain Constraints

Domain Constraints → Design Implications

Domain Rule	Design Constraint	Rust Implication
Stateless HTTP	No request-local globals	State in extractors
Concurrency	Handle many connections	Async, Send + Sync
Latency SLA	Fast response	Efficient ownership
Security	Input validation	Type-safe extractors
Observability	Request tracing	tracing + tower layers

Critical Constraints

Async by Default

RULE: Web handlers must not blockWHY: Block one task = block many requestsRUST: async/await, spawn_blocking for CPU work

RULE: Web handlers must not blockWHY: Block one task = block many requestsRUST: async/await, spawn_blocking for CPU work

State Management

RULE: Shared state must be thread-safeWHY: Handlers run on any threadRUST: Arc<T>, Arc<RwLock<T>> for mutable

RULE: Shared state must be thread-safeWHY: Handlers run on any threadRUST: Arc<T>, Arc<RwLock<T>> for mutable

Request Lifecycle

RULE: Resources live only for request durationWHY: Memory management, no leaksRUST: Extractors, proper ownership

RULE: Resources live only for request durationWHY: Memory management, no leaksRUST: Extractors, proper ownership

Trace Down ↓

From constraints to design (Layer 2):

"Need shared application state"    ↓ m07-concurrency: Use Arc for thread-safe sharing    ↓ m02-resource: Arc<RwLock<T>> for mutable state
"Need request validation"    ↓ m05-type-driven: Validated extractors    ↓ m06-error-handling: IntoResponse for errors
"Need middleware stack"    ↓ m12-lifecycle: Tower layers    ↓ m04-zero-cost: Trait-based composition

"Need shared application state"    ↓ m07-concurrency: Use Arc for thread-safe sharing    ↓ m02-resource: Arc<RwLock<T>> for mutable state
"Need request validation"    ↓ m05-type-driven: Validated extractors    ↓ m06-error-handling: IntoResponse for errors
"Need middleware stack"    ↓ m12-lifecycle: Tower layers    ↓ m04-zero-cost: Trait-based composition

Framework Comparison

Key Crates

Design Patterns

Code Pattern: Axum Handler

rust

async fn handler(    State(db): State<Arc<DbPool>>,    Json(payload): Json<CreateUser>,) -> Result<Json<User>, AppError> {    let user = db.create_user(&payload).await?;    Ok(Json(user))}
// Error handlingimpl IntoResponse for AppError {    fn into_response(self) -> Response {        let (status, message) = match self {            Self::NotFound => (StatusCode::NOT_FOUND, "Not found"),            Self::Internal(_) => (StatusCode::INTERNAL_SERVER_ERROR, "Internal error"),        };        (status, Json(json!({"error": message}))).into_response()    }}

async fn handler(    State(db): State<Arc<DbPool>>,    Json(payload): Json<CreateUser>,) -> Result<Json<User>, AppError> {    let user = db.create_user(&payload).await?;    Ok(Json(user))}
// Error handlingimpl IntoResponse for AppError {    fn into_response(self) -> Response {        let (status, message) = match self {            Self::NotFound => (StatusCode::NOT_FOUND, "Not found"),            Self::Internal(_) => (StatusCode::INTERNAL_SERVER_ERROR, "Internal error"),        };        (status, Json(json!({"error": message}))).into_response()    }}

Common Mistakes

Trace to Layer 1

Constraint	Layer 2 Pattern	Layer 1 Implementation
Async handlers	Async/await	tokio runtime
Thread-safe state	Shared state	Arc<T>, Arc<RwLock<T>>
Request lifecycle	Extractors	Ownership via From<Request>
Middleware	Tower layers	Trait-based composition

Related Skills

Source and attribution

Source:actionbook/rust-skillsinskills/domain-webat commit5c40d3a

License: No license

Content belongs to its original authors. SourceWeft indexes it from a public repository.

Report or request removal

Framework	Style	Best For
axum	Functional, tower	Modern APIs
actix-web	Actor-based	High performance
warp	Filter composition	Composable APIs
rocket	Macro-driven	Rapid development

Pattern	Purpose	Implementation
Extractors	Request parsing	`State(db)`, `Json(payload)`
Error response	Unified errors	`impl IntoResponse`
Middleware	Cross-cutting	Tower layers
Shared state	App config	`Arc<AppState>`

Mistake	Domain Violation	Fix
Blocking in handler	Latency spike	spawn_blocking
Rc in state	Not Send + Sync	Use Arc
No validation	Security risk	Type-safe extractors
No error response	Bad UX	IntoResponse impl

Domain Web

Web Domain

Domain Constraints → Design Implications

Critical Constraints

Async by Default

State Management

Request Lifecycle

Trace Down ↓

Framework Comparison

Key Crates

Design Patterns

Code Pattern: Axum Handler

Common Mistakes

Trace to Layer 1

Related Skills

Source and attribution

More from actionbook/rust-skills

Rust Trait Explorer

Rust Symbol Analyzer

Rust Skill Creator

Rust Router

Rust Refactor Helper

Rust Daily

More in Software Development

Playground

M5 Onboard

Cardputer Buddy

Web Design Guidelines

Vercel React Native Skills

Vercel React Best Practices

Purpose	Crate
HTTP server	axum, actix-web
HTTP client	reqwest
JSON	serde_json
Auth/JWT	jsonwebtoken
Session	tower-sessions
Database	sqlx, diesel
Middleware	tower

When	See
Async patterns	m07-concurrency
State management	m02-resource
Error handling	m06-error-handling
Middleware design	m12-lifecycle