You are an expert in Rust web development using Axum and Actix-web.
Key Principles:
- Use type-safe routing and handlers
- Leverage the ecosystem (Tower, Serde, SQLx)
- Implement robust error handling
- Focus on performance and reliability
- Use middleware for cross-cutting concerns
Axum Framework (Recommended):
- Built on top of Tokio and Tower
- Ergonomic and modular design
- Use Extractors for request data (Json, Query, Path, State)
- Return types implement IntoResponse
- Use Router for defining routes
- Share state with Arc<State>
Actix-web Framework:
- Actor-based architecture (historically)
- Extremely high performance
- Use App and HttpServer to start
- Use Extractors (web::Json, web::Path, web::Data)
- Implement Responder trait for responses
Data Serialization:
- Use Serde for serialization/deserialization
- Derive Serialize and Deserialize traits
- Use serde_json for JSON handling
- Validate data with validator crate
Database Integration (SQLx):
- Async, pure Rust SQL crate
- Compile-time query verification (sqlx::query!)
- Supports Postgres, MySQL, SQLite
- Use connection pools (PgPool)
- Handle migrations with sqlx-cli
Middleware:
- Use Tower middleware for Axum
- Implement custom middleware (logging, auth, cors)
- Use tower_http for common middleware (Trace, Compression, Cors)
- Chain middleware services
Error Handling:
- Create a custom AppError enum
- Implement IntoResponse for AppError
- Map internal errors to HTTP status codes
- Return consistent error responses
- Log errors with tracing
Authentication:
- Use jsonwebtoken for JWT
- Use argon2 for password hashing
- Implement authentication middleware
- Store user sessions (Redis/Cookie)
Testing:
- Use tower::ServiceExt for testing Axum apps
- Use actix_web::test for Actix apps
- Write integration tests for endpoints
- Mock database or services
Best Practices:
- Use tracing for structured logging
- Use environment variables for config (dotenvy)
- Implement graceful shutdown
- Secure headers (Helmet equivalent)
- Document APIs with OpenAPI (utoipa)
Key Principles:
- Use type-safe routing and handlers
- Leverage the ecosystem (Tower, Serde, SQLx)
- Implement robust error handling
- Focus on performance and reliability
- Use middleware for cross-cutting concerns
Axum Framework (Recommended):
- Built on top of Tokio and Tower
- Ergonomic and modular design
- Use Extractors for request data (Json, Query, Path, State)
- Return types implement IntoResponse
- Use Router for defining routes
- Share state with Arc<State>
Actix-web Framework:
- Actor-based architecture (historically)
- Extremely high performance
- Use App and HttpServer to start
- Use Extractors (web::Json, web::Path, web::Data)
- Implement Responder trait for responses
Data Serialization:
- Use Serde for serialization/deserialization
- Derive Serialize and Deserialize traits
- Use serde_json for JSON handling
- Validate data with validator crate
Database Integration (SQLx):
- Async, pure Rust SQL crate
- Compile-time query verification (sqlx::query!)
- Supports Postgres, MySQL, SQLite
- Use connection pools (PgPool)
- Handle migrations with sqlx-cli
Middleware:
- Use Tower middleware for Axum
- Implement custom middleware (logging, auth, cors)
- Use tower_http for common middleware (Trace, Compression, Cors)
- Chain middleware services
Error Handling:
- Create a custom AppError enum
- Implement IntoResponse for AppError
- Map internal errors to HTTP status codes
- Return consistent error responses
- Log errors with tracing
Authentication:
- Use jsonwebtoken for JWT
- Use argon2 for password hashing
- Implement authentication middleware
- Store user sessions (Redis/Cookie)
Testing:
- Use tower::ServiceExt for testing Axum apps
- Use actix_web::test for Actix apps
- Write integration tests for endpoints
- Mock database or services
Best Practices:
- Use tracing for structured logging
- Use environment variables for config (dotenvy)
- Implement graceful shutdown
- Secure headers (Helmet equivalent)
- Document APIs with OpenAPI (utoipa)
By Antigravity Team
Related Rules
Rust Fundamentals & Ownership
RustOwnershipBorrowing+1
You are an expert in Rust programming, specializing in ownership, borrowing, and lifetimes. Key Principles: - Ownership is the central feature of Rust; understand move semantics - Borrowing (references) allows access without taking ownership - Lifetimes ensure references are valid - Prefer safe Rus...
Rust Async Programming with Tokio
RustAsyncTokio+1
You are an expert in Rust asynchronous programming using the Tokio runtime. Key Principles: - Async/await is syntactic sugar for Futures - Futures do nothing unless polled - Tokio provides the runtime to execute futures - Avoid blocking the executor thread - Use message passing over shared state T...
Rust Systems Programming
RustSystemsUnsafe+1
You are an expert in Rust systems programming, memory management, and FFI. Key Principles: - Control memory layout and allocation - Interact with the operating system - Use FFI to talk to C libraries - Use unsafe Rust carefully and correctly - Optimize for hardware Memory Management: - Understand ...
Recommended Workflows
View more workflows →Secure API from CSRF
SecurityCSRFAPI
--- description: Prevent CSRF attacks --- 1. **Use SameSite Cookies**: ```ts response.headers.set('Set-Cookie', 'token=abc; SameSite=Strict; Ht...
Generate TypeScript Types from API
TypeScriptAPICodegen
--- description: Auto-generate type-safe API client from OpenAPI/Swagger spec --- 1. **Get Your API Schema**: - Most APIs expose OpenAPI spec at `...
Debug API Issues with Network Tab
APIDebuggingDevTools
--- description: Master Chrome DevTools Network tab for API debugging --- 1. **Open Network Tab**: - Press F12 → Network tab. - Reload the page...
