Struct RustApi 

pub struct RustApi { /* private fields */ }

Main application builder for RustAPI

Example

use rustapi_rs::prelude::*;

#[tokio::main]
async fn main() -> Result<()> {
    RustApi::new()
        .state(AppState::new())
        .route("/", get(hello))
        .route("/users/{id}", get(get_user))
        .run("127.0.0.1:8080")
        .await
}

Implementations

impl RustApi

pub fn new() -> Self

Create a new RustAPI application

pub fn state<S>(self, _state: S) -> Self

where S: Clone + Send + Sync + 'static,

Add application state

State is shared across all handlers and can be extracted using State<T>.

Example

#[derive(Clone)]
struct AppState {
    db: DbPool,
}

RustApi::new()
    .state(AppState::new())

pub fn register_schema<T: for<'a> Schema<'a>>(self) -> Self

Register an OpenAPI schema

Example

#[derive(Schema)]
struct User { ... }

RustApi::new()
    .register_schema::<User>()

pub fn openapi_info( self, title: &str, version: &str, description: Option<&str>, ) -> Self

Configure OpenAPI info (title, version, description)

pub fn route(self, path: &str, method_router: MethodRouter) -> Self

Add a route

Example

RustApi::new()
    .route("/", get(index))
    .route("/users", get(list_users).post(create_user))
    .route("/users/{id}", get(get_user).delete(delete_user))

pub fn mount(self, path: &str, method_router: MethodRouter) -> Self

👎Deprecated: Use route() directly or mount_route() for macro-based routing

Mount a handler (convenience method)

Alias for .route(path, method_router) for a single handler.

pub fn mount_route(self, route: Route) -> Self

Mount a route created with #[rustapi::get], #[rustapi::post], etc.

Example

use rustapi_rs::prelude::*;

#[rustapi::get("/users")]
async fn list_users() -> Json<Vec<User>> {
    Json(vec![])
}

RustApi::new()
    .mount_route(route!(list_users))
    .run("127.0.0.1:8080")
    .await

pub fn nest(self, prefix: &str, router: Router) -> Self

Nest a router under a prefix

Example

let api_v1 = Router::new()
    .route("/users", get(list_users));

RustApi::new()
    .nest("/api/v1", api_v1)

pub fn docs(self, path: &str) -> Self

Enable Swagger UI documentation

This adds two endpoints:

• {path} - Swagger UI interface
• {path}/openapi.json - OpenAPI JSON specification

Example

RustApi::new()
    .route("/users", get(list_users))
    .docs("/docs")  // Swagger UI at /docs, spec at /docs/openapi.json
    .run("127.0.0.1:8080")
    .await

pub fn docs_with_info( self, path: &str, title: &str, version: &str, description: Option<&str>, ) -> Self

Enable Swagger UI documentation with custom API info

Example

RustApi::new()
    .docs_with_info("/docs", "My API", "2.0.0", Some("API for managing users"))

pub async fn run(self, addr: &str) -> Result<(), Box<dyn Error + Send + Sync>>

Run the server

Example

RustApi::new()
    .route("/", get(hello))
    .run("127.0.0.1:8080")
    .await

pub fn into_router(self) -> Router

Get the inner router (for testing or advanced usage)

Trait Implementations

impl Default for RustApi

fn default() -> Self

Returns the “default value” for a type.