rustapi-rs 0.1.501

A FastAPI-like web framework for Rust - DX-first, type-safe, batteries included
Documentation

License Crates.io Docs.rs

🚀 Vision

RustAPI brings the developer experience (DX) of modern frameworks like FastAPI to the Rust ecosystem.

We believe that writing high-performance, type-safe web APIs in Rust shouldn't require fighting with complex trait bounds or massive boilerplate. RustAPI provides a polished, battery-included experience where:

  • API Design is First-Class: Define your schema, and let the framework handle Validation and OpenAPI documentation automatically.
  • The Engine is Abstracted: We rely on industry standards like tokio, hyper, and matchit internally, but we expose a stable, user-centric API.
  • Zero Boilerplate: Extractors and macros do the heavy lifting.

✨ Features

  • ⚡ Fast & Async: Built on top of tokio and hyper 1.0.
  • 🛡️ Type-Safe: Request/Response bodies are strictly typed using generic extractors (Json, Query, Path).
  • 📝 Auto-Docs: Generates OpenAPI 3.0 specifications and serves Swagger UI automatically.
  • ✅ Validation: Declarative validation using #[derive(Validate)].
  • 🔌 Batteries Included:
    • Authentication: JWT support.
    • Database: SQLx integration.
    • WebSockets: Real-time communication.
    • Templating: Tera view engine.
    • Jobs: Background task processing (Redis/Postgres).

Feature taxonomy on the facade:

  • core-*: core runtime and HTTP behavior (core-openapi, core-tracing, etc.)
  • protocol-*: optional protocol crates (protocol-toon, protocol-ws, protocol-view, protocol-grpc)
  • extras-*: optional production middleware/integrations (extras-jwt, extras-cors, etc.)

📦 Quick Start

Önerilen kullanım (en temiz ve kısa makro isimleri için):

[dependencies]

api = { package = "rustapi-rs", version = "0.1.478" }

Sonra kodunda:

use api::prelude::*;

#[api::get("/hello")]
async fn hello() -> &'static str {
    "Hello from RustAPI!"
}

#[api::main]
async fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
    api::RustApi::auto().run("127.0.0.1:8080").await
}

Eğer istersen direkt uzun isimle de kullanabilirsin:

[dependencies]

rustapi-rs = "0.1.478"


use rustapi_rs::prelude::*;

#[rustapi_rs::get("/hello")]
...

Add rustapi-rs to your Cargo.toml (kısa isim için alias önerilir):

[dependencies]

rustapi-rs = { version = "0.1", features = ["full"] }

The "Hello World"

use rustapi_rs::prelude::*;

/// Define your response schema
#[derive(Serialize, Schema)]
struct HelloResponse {
    message: String,
}

/// Define an endpoint
#[rustapi_rs::get("/")]
#[rustapi_rs::tag("General")]
#[rustapi_rs::summary("Hello World Endpoint")]
async fn hello() -> Json<HelloResponse> {
    Json(HelloResponse {
        message: "Hello from RustAPI!".to_string(),
    })
}

#[rustapi_rs::main]
async fn main() -> Result<()> {
    RustApi::auto().run("127.0.0.1:8080").await
}

Visit http://127.0.0.1:8080/docs to see your interactive API documentation!

🗺️ Architecture

RustAPI follows a Facade Architecture:

  • rustapi-rs: The public-facing entry point. Always import from here.
  • rustapi-core: The internal engine (Hyper/Tower).
  • rustapi-macros: Procedural macros (#[get], #[main]).
  • cargo-rustapi: The CLI tool for scaffolding projects.

🤝 Contributing

We welcome contributions! Please see CONTRIBUTING.md for details.

📄 License

This project is licensed under either of

at your option.