Rovo

https://docs.rs/rovo/latest/rovo
Admin
Rovo is a lightweight macro-based framework for generating OpenAPI documentation from doc comments...
Tokens:689,440
Snippets:4,454
Trust Score:9.7
Update:9 months ago
Show doc for...
Tokens:
Raw
### Axum Router Setup with RawQuery

Source: https://docs.rs/rovo/latest/rovo/extract/struct.RawQuery_search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Illustrates setting up an Axum router to use the handler function that consumes the RawQuery extractor. This example shows a basic GET route for '/users'.

```rust
use axum::{routing::get, Router};

let app = Router::new().route("/users", get(handler));
```

--------------------------------

### Rovo Routing Example with axum

Source: https://docs.rs/rovo/latest/rovo/routing/index_search=

Demonstrates how to use Rovo's routing functions with #[rovo] decorated async handlers in an axum application. This example showcases defining routes for GET, POST, PATCH, and DELETE HTTP methods.

```rust
use rovo::{
    Router,
    rovo,
    routing::{get, post, patch, delete},
    aide::axum::IntoApiResponse,
};
use rovo::response::Json;

#[rovo]
async fn list_items() -> impl IntoApiResponse {
    Json(())
}
#[rovo]
async fn create_item() -> impl IntoApiResponse {
    Json(())
}
#[rovo]
async fn get_item() -> impl IntoApiResponse {
    Json(())
}
#[rovo]
async fn update_item() -> impl IntoApiResponse {
    Json(())
}
#[rovo]
async fn delete_item() -> impl IntoApiResponse {
    Json(())
}

Router::new()
    .route("/items", get(list_items).post(create_item))
    .route("/items/{id}", get(get_item).patch(update_item).delete(delete_item));
```

--------------------------------

### Rovo Quick Start Example in Rust

Source: https://docs.rs/rovo/latest/rovo/index

Demonstrates how to use the Rovo crate to define an Axum API endpoint with documentation generated from doc comments. It shows setting up the API, defining a user struct, and creating a handler with path parameters, responses, and metadata.

```rust
use rovo::{Router, rovo, routing::get, schemars::JsonSchema, aide::axum::IntoApiResponse};
use rovo::aide::openapi::OpenApi;
use rovo::{extract::Path, response::Json};
use serde::Serialize;

#[derive(Serialize, JsonSchema)]
struct User { id: u32, name: String }

/// Get user by ID
///
/// # Path Parameters
///
/// id: The user ID
///
/// # Responses
///
/// 200: Json<User> - User found successfully
/// 404: () - User not found
///
/// # Metadata
///
/// @tag users
#[rovo]
async fn get_user(Path(id): Path<u32>) -> impl IntoApiResponse {
    Json(User { id, name: "Alice".to_string() })
}

let mut api = OpenApi::default();
api.info.title = "My API".to_string();

let app = Router::new()
    .route("/users/{id}", get(get_user))
    .with_oas(api);
```

--------------------------------

### Rovo Routing Example with #[rovo] Handlers

Source: https://docs.rs/rovo/latest/rovo/routing/index

Demonstrates how to use Rovo's routing functions (get, post, patch, delete) with #[rovo] decorated asynchronous functions to define API endpoints. It shows the setup of a basic router with different HTTP methods for item-related resources.

```rust
use rovo::{Router, rovo, routing::{get, post, patch, delete}, aide::axum::IntoApiResponse};
use rovo::response::Json;

#[rovo] async fn list_items() -> impl IntoApiResponse { Json(()) }
#[rovo] async fn create_item() -> impl IntoApiResponse { Json(()) }
#[rovo] async fn get_item() -> impl IntoApiResponse { Json(()) }
#[rovo] async fn update_item() -> impl IntoApiResponse { Json(()) }
#[rovo] async fn delete_item() -> impl IntoApiResponse { Json(()) }

Router::new()
    .route("/items", get(list_items).post(create_item))
    .route("/items/{id}", get(get_item).patch(update_item).delete(delete_item));

```

--------------------------------

### Response Examples

Source: https://docs.rs/rovo/latest/rovo/response/type.Response_search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Examples demonstrating the usage of the Response struct, including mapping and byte conversion.

```APIDOC
## Examples

```rust
let response = Response::builder().body("some string").unwrap();
let mapped_response: Response<&[u8]> = response.map(|b| {
  assert_eq!(b, "some string");
  b.as_bytes()
});
assert_eq!(mapped_response.body(), &"some string".as_bytes());
```
```

--------------------------------

### GET /

Source: https://docs.rs/rovo/latest/rovo/routing/fn.get_search=

Creates a GET route using a handler decorated with `#[rovo]`. This allows for defining custom documentation for your GET endpoints.

```APIDOC
## GET /

### Description
Create a GET route with documentation from a `#[rovo]` decorated handler.

### Method
GET

### Endpoint
/

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```json
{
  "handler": "#[rovo] handler"
}
```

### Response
#### Success Response (200)
- **result** (any) - The result of the handler execution.

#### Response Example
```json
{
  "result": "Handler output"
}
```
```

--------------------------------

### Rust Example Searches

Source: https://docs.rs/rovo/latest/rovo/extract/rejection/struct.InvalidFormContentType_search=

This section provides examples of common search queries in a Rust context, illustrating type patterns and functional transformations. These examples are useful for understanding how to query types and associated functions within Rust documentation or codebases.

```rust
std::vec
```

```rust
u32 -> bool
```

```rust
Option<T>, (T -> U) -> Option<U>
```

--------------------------------

### SSE Handler Example

Source: https://docs.rs/rovo/latest/rovo/response/sse/index_search=u32+-%3E+bool

An example demonstrating how to set up a handler for Server-Sent Events using Axum and the rovo crate. This handler streams 'hi!' events every second.

```APIDOC
## GET /sse

### Description
Handles Server-Sent Events (SSE) by streaming a message every second.

### Method
GET

### Endpoint
/sse

### Parameters
None

### Request Body
None

### Response
#### Success Response (200)
- **Content-Type** (string) - `text/event-stream`
- The response will be a stream of SSE events.

#### Response Example
```
event: message
data: hi!

```
(This event repeats every second)
```

--------------------------------

### Axum Router Setup with RawQuery Handler (Rust)

Source: https://docs.rs/rovo/latest/rovo/extract/struct.RawQuery

Illustrates how to set up an Axum router to handle requests to a specific route, using a handler function that accepts the RawQuery extractor. This is part of the example for the RawQuery struct.

```rust
use axum::{
    routing::get,
    Router,
};

let app = Router::new().route("/users", get(handler));
```

--------------------------------

### Example of Rovo Routing with #[rovo] Handlers (Rust)

Source: https://docs.rs/rovo/latest/rovo/routing/index_search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

This example demonstrates how to use Rovo's routing functions with handlers decorated by #[rovo]. It showcases defining routes for GET, POST, PATCH, and DELETE HTTP methods and associating them with asynchronous handler functions. The functions automatically include documentation generated from the #[rovo] attribute.

```rust
use rovo::{Router, rovo, routing::{get, post, patch, delete}, aide::axum::IntoApiResponse};
use rovo::response::Json;

#[rovo] async fn list_items() -> impl IntoApiResponse { Json(()) }
#[rovo] async fn create_item() -> impl IntoApiResponse { Json(()) }
#[rovo] async fn get_item() -> impl IntoApiResponse { Json(()) }
#[rovo] async fn update_item() -> impl IntoApiResponse { Json(()) }
#[rovo] async fn delete_item() -> impl IntoApiResponse { Json(()) }

Router::new()
    .route("/items", get(list_items).post(create_item))
    .route("/items/{id}", get(get_item).patch(update_item).delete(delete_item));
```

--------------------------------

### Rust Example Searches: Type Signatures and Generics

Source: https://docs.rs/rovo/latest/rovo/extract/rejection/struct.MissingJsonContentType_search=

Provides examples of common search queries used in Rust, illustrating how to look for specific type signatures and generic patterns. These examples are useful for navigating and understanding Rust codebases, especially when searching for functions or types related to collections, boolean conversions, and functional transformations.

```rust
// Example search: std::vec
// Example search: u32 -> bool
// Example search: Option<T>, (T -> U) -> Option<U>
```

--------------------------------

### Rovo Example: Tuple Path Parameters

Source: https://docs.rs/rovo/latest/rovo/attr.rovo

An example of a Rust handler function using Rovo to document tuple path parameters, combining multiple types within a single Path extractor.

```rust
/// Get item in collection.
///
/// # Path Parameters
///
/// collection_id: The collection UUID
/// index: Item index within collection
///
/// # Responses
///
/// 200: Json<Item> - Item found
#[rovo]
async fn get_item(
    Path((collection_id, index)): Path<(Uuid, u32)>
) -> impl IntoApiResponse {
    // ...
}

```

--------------------------------

### rovo Example: Primitive Path Parameter

Source: https://docs.rs/rovo/latest/rovo/attr.rovo_search=std%3A%3Avec

This example demonstrates how to use rovo to document an API endpoint that retrieves a user by their ID. It includes documentation for the path parameter and the expected responses.

```rust
/// Get user by ID.
///
/// # Path Parameters
///
/// id: The user's numeric identifier
///
/// # Responses
///
/// 200: Json<User> - User found
/// 404: () - User not found
#[rovo]
async fn get_user(Path(id): Path<u64>) -> impl IntoApiResponse {
    // ...
}
```

--------------------------------

### Rovo Example: Primitive Path Parameter

Source: https://docs.rs/rovo/latest/rovo/attr.rovo

An example of a Rust handler function using the Rovo macro to document a primitive path parameter ('id') and responses.

```rust
/// Get user by ID.
///
/// # Path Parameters
///
/// id: The user's numeric identifier
///
/// # Responses
///
/// 200: Json<User> - User found
/// 404: () - User not found
#[rovo]
async fn get_user(Path(id): Path<u64>) -> impl IntoApiResponse {
    // ...
}

```

--------------------------------

### Rust: Create GET Request Shortcut

Source: https://docs.rs/rovo/latest/rovo/extract/type.Request_search=

Provides a convenient shortcut `Request::get()` for creating a GET request with a specified URI. The builder is initialized with the GET method and the provided URI, simplifying common GET request creation.

```rust
let request = Request::get("https://www.rust-lang.org/")
    .body(())
    .unwrap();

```

--------------------------------

### Example Usage

Source: https://docs.rs/rovo/latest/rovo/struct.ApiMethodRouter

Demonstrates how to use ApiMethodRouter with rovo-decorated async functions to define API routes.

```APIDOC
## §Example
```rust
use rovo::{Router, rovo, routing::{get, post, patch, delete}, aide::axum::IntoApiResponse};
use rovo::response::Json;

#[rovo] async fn list_items() -> impl IntoApiResponse { Json(()) }
#[rovo] async fn create_item() -> impl IntoApiResponse { Json(()) }
#[rovo] async fn get_item() -> impl IntoApiResponse { Json(()) }
#[rovo] async fn update_item() -> impl IntoApiResponse { Json(()) }
#[rovo] async fn delete_item() -> impl IntoApiResponse { Json(()) }

Router::new()
    .route("/items", get(list_items).post(create_item))
    .route("/items/{id}", get(get_item).patch(update_item).delete(delete_item));
```
```

--------------------------------

### rovo Example: Tuple Path Parameters

Source: https://docs.rs/rovo/latest/rovo/attr.rovo_search=std%3A%3Avec

This example illustrates documenting an API endpoint that uses a tuple for path parameters, combining a UUID and an integer. rovo correctly parses these tuple path parameters for OpenAPI documentation.

```rust
/// Get item in collection.
///
/// # Path Parameters
///
/// collection_id: The collection UUID
/// index: Item index within collection
///
/// # Responses
///
/// 200: Json<Item> - Item found
#[rovo]
async fn get_item(
    Path((collection_id, index)): Path<(Uuid, u32)>
) -> impl IntoApiResponse {
    // ...
}
```

--------------------------------

### Create GET Request with Builder in Rust

Source: https://docs.rs/rovo/latest/rovo/extract/type.Request_search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Shows how to create an HTTP GET request using the Request builder in Rust. This method initializes the builder with the GET method and a specified URI.

```rust
let request = Request::get("https://www.rust-lang.org/")
    .body(()) // Specify the body type here, e.g., ()
    .unwrap();
```

--------------------------------

### rovo Example: Struct-based Path Parameters

Source: https://docs.rs/rovo/latest/rovo/attr.rovo_search=std%3A%3Avec

This example shows how to document a path parameter using a struct (e.g., `SelectTodo`) when dealing with complex types. The struct must implement `JsonSchema` for rovo to generate the correct OpenAPI schema.

```rust
/// Get a single Todo item.
///
/// Retrieve a Todo item by its ID from the database.
///
/// # Responses
///
/// 200: Json<TodoItem> - Successfully retrieved the todo item
/// 404: () - Todo item was not found
///
/// # Examples
///
/// 200: TodoItem::default()
///
/// # Metadata
///
/// @tag todos
#[rovo]
async fn get_todo(
    State(app): State<AppState>,
    Path(todo): Path<SelectTodo>  // SelectTodo implements JsonSchema
) -> impl IntoApiResponse {
    // ...
}
```

--------------------------------

### Rust Search Example: Option and Mapping

Source: https://docs.rs/rovo/latest/rovo/extract/rejection/struct.NestedPathRejection_search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

This example shows a search query for a common functional pattern in Rust involving `Option<T>` and mapping a function `T -> U` to produce `Option<U>`.

```rust
Option<T>, (T -> U) -> Option<U>
```

--------------------------------

### Example Usage of MockConnectInfo for Testing in Rust

Source: https://docs.rs/rovo/latest/rovo/extract/connect_info/struct.MockConnectInfo_search=

This Rust example demonstrates how to use MockConnectInfo for testing an Axum application. It sets up a test router with mocked connection information and makes a request to verify the application's response.

```rust
use axum::{
    Router,
    extract::connect_info::{MockConnectInfo, ConnectInfo},
    body::Body,
    routing::get,
    http::{Request, StatusCode},
};
use std::net::SocketAddr;
use tower::ServiceExt;

async fn handler(ConnectInfo(addr): ConnectInfo<SocketAddr>) {}

// this router you can run with `app.into_make_service_with_connect_info::<SocketAddr>()`
fn app() -> Router {
    Router::new().route("/", get(handler))
}

// use this router for tests
fn test_app() -> Router {
    app().layer(MockConnectInfo(SocketAddr::from(([0, 0, 0, 0], 1337))))
}

// #[tokio::test]
async fn some_test() {
    let app = test_app();

    let request = Request::new(Body::empty());
    let response = app.oneshot(request).await.unwrap();
    assert_eq!(response.status(), StatusCode::OK);
}

```

--------------------------------

### Rovo: Providing Response Examples in Doc Comments

Source: https://docs.rs/rovo/latest/rovo/index_search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Shows how to include example responses directly within Rust doc comments for API endpoints processed by Rovo. This aids in understanding the expected data format for different status codes.

```rust
/// # Examples
///
/// 200: User { id: 1, name: "Alice".into() }
/// 404: ()

```

--------------------------------

### Rust: Create Request with Builder (GET)

Source: https://docs.rs/rovo/latest/rovo/extract/type.Request_search=

Demonstrates creating an HTTP GET request using the `Request::builder()` method. This builder pattern allows for setting the method, URI, and headers before constructing the final request with a body.

```rust
let request = Request::builder()
    .method("GET")
    .uri("https://www.rust-lang.org/")
    .header("X-Custom-Foo", "Bar")
    .body(())
    .unwrap();

```

--------------------------------

### SSE Handler Example

Source: https://docs.rs/rovo/latest/rovo/response/sse/index_search=

This example demonstrates how to create an SSE handler using Rovo's Sse response type with Axum. It sets up a stream that sends a 'hi!' event every second and configures keep-alive messages.

```APIDOC
## GET /sse

### Description
Handles Server-Sent Events (SSE) by providing a stream of events to the client.

### Method
GET

### Endpoint
/sse

### Parameters
#### Query Parameters
None

#### Path Parameters
None

### Request Body
None

### Response
#### Success Response (200)
- **Sse** (Sse<impl Stream<Item = Result<Event, Infallible>>>) - An SSE response stream that sends events to the client.

#### Response Example
```rust
use axum::{
    Router,
    routing::get,
    response::sse::{Event, KeepAlive, Sse},
};
use std::{time::Duration, convert::Infallible};
use tokio_stream::StreamExt as _ ;
use futures_util::stream::{self, Stream};

let app = Router::new().route("/sse", get(sse_handler));

async fn sse_handler() -> Sse<impl Stream<Item = Result<Event, Infallible>>> {
    // A `Stream` that repeats an event every second
    let stream = stream::repeat_with(|| Event::default().data("hi!"))
        .map(Ok)
        .throttle(Duration::from_secs(1));

    Sse::new(stream).keep_alive(KeepAlive::default())
}
```

### Error Handling
- **Infallible**: The stream is designed to never fail, so `Infallible` is used as the error type.
```

--------------------------------

### Example Usage of MockConnectInfo for Testing (Rust)

Source: https://docs.rs/rovo/latest/rovo/extract/connect_info/struct.MockConnectInfo

Demonstrates how to use MockConnectInfo to mock connection information in tests for an Axum router. This example shows setting up a test application with mocked `SocketAddr` and making a request to verify the handler execution.

```rust
use axum::{
    Router,
    extract::connect_info::{MockConnectInfo, ConnectInfo},
    body::Body,
    routing::get,
    http::{Request, StatusCode},
};
use std::net::SocketAddr;
use tower::ServiceExt;

async fn handler(ConnectInfo(addr): ConnectInfo<SocketAddr>) {}

// this router you can run with `app.into_make_service_with_connect_info::<SocketAddr>()`
fn app() -> Router {
    Router::new().route("/", get(handler))
}

// use this router for tests
fn test_app() -> Router {
    app().layer(MockConnectInfo(SocketAddr::from(([0, 0, 0, 0], 1337))))
}

// #[tokio::test]
async fn some_test() {
    let app = test_app();

    let request = Request::new(Body::empty());
    let response = app.oneshot(request).await.unwrap();
    assert_eq!(response.status(), StatusCode::OK);
}
```

--------------------------------

### Create and Configure rovo::Router with OpenAPI

Source: https://docs.rs/rovo/latest/rovo/struct.Router_search=std%3A%3Avec

This example demonstrates initializing a new `rovo::Router` and configuring it with an `OpenApi` specification. It shows how to add a documented route and integrate the OpenAPI spec, which will be served at default endpoints.

```rust
use rovo::{Router, rovo, routing::get, aide::axum::IntoApiResponse};
use rovo::aide::openapi::OpenApi;
use rovo::response::Json;

#[rovo]
async fn documented_handler() -> impl IntoApiResponse {
    Json(())
}

let mut api = OpenApi::default();
api.info.title = "My API".to_string();

let app = Router::new()
    .route("/documented", get(documented_handler))
    .with_oas(api);
```

--------------------------------

### Get Query String of Uri

Source: https://docs.rs/rovo/latest/rovo/extract/struct.OriginalUri_search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Retrieves the query string component of a URI, starting after the '?'.

```APIDOC
## GET /uri/query

### Description
Get the query string of this `Uri`, starting after the `?`.
The query component contains non-hierarchical data that, along with data in the path component, serves to identify a resource within the scope of the URI’s scheme and naming authority (if any). The query component is indicated by the first question mark (“?”) character and terminated by a number sign (“#”) character or by the end of the URI.

### Method
GET

### Endpoint
`/uri/query`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

### Request Example
```json
{
  "uri_string": "http://example.org/hello/world?key=value&foo=bar"
}
```

### Response
#### Success Response (200)
- **query** (string) - The query string of the URI, or null if not present.

#### Response Example
```json
{
  "query": "key=value&foo=bar"
}
```
```

--------------------------------

### Define RawForm Struct and Usage Example in Rust

Source: https://docs.rs/rovo/latest/rovo/extract/struct.RawForm_search=

Defines the RawForm struct which wraps Bytes for raw form data extraction. Includes an example demonstrating its use with Axum's Router for handling GET requests.

```rust
pub struct RawForm(pub Bytes);

// Example usage with Axum
use axum::extract::RawForm;
use axum::routing::get;
use axum::Router;

async fn handler(RawForm(form): RawForm) {}

let app = Router::new().route("/", get(handler));

```

--------------------------------

### Quick Start: Rovo OpenAPI Documentation with Axum

Source: https://docs.rs/rovo/latest/rovo/index_search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Demonstrates how to use the Rovo crate to generate OpenAPI documentation for Axum handlers. It includes setting up the API structure, defining a user model, creating a handler with doc comments for OpenAPI, and initializing the API with Rovo.

```rust
use rovo::{Router, rovo, routing::get, schemars::JsonSchema, aide::axum::IntoApiResponse};
use rovo::aide::openapi::OpenApi;
use rovo::{extract::Path, response::Json};
use serde::Serialize;

#[derive(Serialize, JsonSchema)]
struct User { id: u32, name: String }

/// Get user by ID
///
/// # Path Parameters
///
/// id: The user ID
///
/// # Responses
///
/// 200: Json<User> - User found successfully
/// 404: () - User not found
///
/// # Metadata
///
/// @tag users
#[rovo]
async fn get_user(Path(id): Path<u32>) -> impl IntoApiResponse {
    Json(User { id, name: "Alice".to_string() })
}

let mut api = OpenApi::default();
api.info.title = "My API".to_string();

let app = Router::new()
    .route("/users/{id}", get(get_user))
    .with_oas(api);

```

--------------------------------

### Router Basics

Source: https://docs.rs/rovo/latest/rovo/struct.Router_search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Illustrates the basic setup and usage of the Rovo Router, including adding routes and integrating OpenAPI specifications.

```APIDOC
## Struct Router

A drop-in replacement for `axum::Router` that adds `OpenAPI` documentation support.
This Router works seamlessly with handlers decorated with `#[rovo]` and provides a fluent API for building documented APIs with Swagger UI integration.

### Example
```rust
use rovo::{Router, rovo, routing::get, aide::axum::IntoApiResponse};
use rovo::aide::openapi::OpenApi;
use rovo::response::Json;

#[rovo]
async fn documented_handler() -> impl IntoApiResponse {
    Json(())
}

let mut api = OpenApi::default();
api.info.title = "My API".to_string();

let app = Router::new()
    .route("/documented", get(documented_handler))
    .with_oas(api);
```
```

--------------------------------

### Mutate Response Body (Rust)

Source: https://docs.rs/rovo/latest/rovo/response/type.Response_search=u32+-%3E+bool

Shows how to get a mutable reference to the response body and modify its content, for example, by appending a string.

```rust
let mut response: Response<String> = Response::default();
response.body_mut().push_str("hello world");
assert!(!response.body().is_empty());

```

--------------------------------

### Router Initialization and Routing

Source: https://docs.rs/rovo/latest/rovo/struct.Router_search=

These methods provide basic functionality for creating and configuring a Router. `new()` initializes an empty router, `route()` adds a specific HTTP method and handler to a path, and `nest()` allows for grouping routes under a common path prefix.

```rust
pub fn new() -> Self
```

```rust
pub fn route<M>(self, path: &str, method_router: M) -> Self
where M: Into<ApiMethodRouter<S>>
```

```rust
pub fn nest(self, path: &str, router: Self) -> Self
```

--------------------------------

### MatchedPath - Basic Usage

Source: https://docs.rs/rovo/latest/rovo/extract/struct.MatchedPath_search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Shows a basic example of extracting MatchedPath directly in a handler to get the string representation of the matched route.

```APIDOC
## Basic Usage of MatchedPath

Access the path in the router that matches the request.

### Example
```rust
use axum::{
    Router,
    extract::MatchedPath,
    routing::get,
};

let app = Router::new().route(
    "/users/{id}",
    get(|path: MatchedPath| async move {{
        let path_str = path.as_str();
        // `path_str` will be "/users/{id}"
        // You can return it or process it further
        path_str
    }})
);
```
```

--------------------------------

### CloneToUninit Trait Implementations

Source: https://docs.rs/rovo/latest/rovo/extract/struct.Extension_search=

Documentation for the nightly-only experimental API `clone_to_uninit`.

```APIDOC
## CloneToUninit Trait (Nightly Only)

### Description
Experimental API for performing copy-assignment to uninitialized memory.

### Methods

#### `unsafe fn clone_to_uninit(&self, dest: *mut u8)`
Performs copy-assignment from `self` to `dest`.

Source: [Link to Source]
```

--------------------------------

### Get Scheme String from Uri Struct

Source: https://docs.rs/rovo/latest/rovo/extract/struct.OriginalUri_search=u32+-%3E+bool

Provides an example of extracting the scheme of a `Uri` as a string slice. This method is useful for direct string comparisons or logging.

```rust
use http::Uri;

let uri: Uri = "http://example.org/hello/world".parse().unwrap();

assert_eq!(uri.scheme_str(), Some("http"));
```

--------------------------------

### Get URI Query String (Rust)

Source: https://docs.rs/rovo/latest/rovo/extract/struct.OriginalUri_search=

Extracts the query string component of a Uri, starting after the '?'. The query is terminated by '#' or the end of the URI. It returns an Option<&str>.

```rust
/// Get the query string of this `Uri`, starting after the `?`.
///
/// The query component contains non-hierarchical data that, along with data in the path component, serves to identify a resource within the scope of the URI’s scheme and naming authority (if any). The query component is indicated by the first question mark (“?”) character and terminated by a number sign (“#”) character or by the end of the URI.
///
/// # Examples
/// ```
/// use rs_rovo_rovo::Uri;
///
/// let uri: Uri = "http://example.org/hello/world?key=value".parse().unwrap();
/// assert_eq!(uri.query(), Some("key=value"));
///
/// let uri: Uri = "/hello/world?key=value&foo=bar".parse().unwrap();
/// assert_eq!(uri.query(), Some("key=value&foo=bar"));
///
/// let uri: Uri = "/hello/world".parse().unwrap();
/// assert!(uri.query().is_none());
/// ```
pub fn query(&self) -> Option<&str>
```

--------------------------------

### Extract Raw Query String with Axum

Source: https://docs.rs/rovo/latest/rovo/extract/struct.RawQuery_search=

This example demonstrates how to use the RawQuery extractor with Axum to get the raw query string from an incoming request. The RawQuery extractor itself has no external dependencies beyond Axum. It takes the raw query string as an Option<String>.

```rust
use axum::extract::RawQuery;
use axum::routing::get;
use axum::Router;

async fn handler(RawQuery(query): RawQuery) {
    // query is of type Option<String>
    // Process the raw query string here
}

let app = Router::new().route("/users", get(handler));
```

--------------------------------

### CloneToUninit Trait Implementations

Source: https://docs.rs/rovo/latest/rovo/response/struct.Extension_search=std%3A%3Avec

Documentation for methods available through the `CloneToUninit` trait (nightly-only experimental API).

```APIDOC
## CloneToUninit<T>

### Description
Performs copy-assignment from `self` to a destination.

### Methods
#### unsafe fn clone_to_uninit(&self, dest: *mut u8)
Performs copy-assignment from `self` to `dest`.
```

--------------------------------

### Create Response using Builder (Rust)

Source: https://docs.rs/rovo/latest/rovo/response/type.Response_search=u32+-%3E+bool

Demonstrates how to construct an HTTP `Response` using a builder pattern. This allows for setting status codes, headers, and the body in a fluent manner.

```rust
let response = Response::builder()
    .status(200)
    .header("X-Custom-Foo", "Bar")
    .body(())
    .unwrap();

```

--------------------------------

### GET /

Source: https://docs.rs/rovo/latest/rovo/routing/fn.get_search=std%3A%3Avec

Defines a GET route using a handler. This function allows you to create a new API endpoint that responds to GET requests.

```APIDOC
## GET /

### Description
Create a GET route with documentation from a `#[rovo]` decorated handler.

### Method
GET

### Endpoint
/

### Parameters
#### Query Parameters
- **handler** (H) - Required - The handler function that will process GET requests.

### Request Example
```rust
// Example usage within a Rovo application:
router.get(my_get_handler);
```

### Response
#### Success Response (200)
- **ApiMethodRouter<S>** (ApiMethodRouter) - The configured router for the GET endpoint.
```

--------------------------------

### GET /

Source: https://docs.rs/rovo/latest/rovo/routing/fn.get_search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Creates a GET route using a handler decorated with `#[rovo]`. This function allows you to define custom handlers for GET requests.

```APIDOC
## GET /

### Description
Creates a GET route with documentation from a `#[rovo]` decorated handler.

### Method
GET

### Endpoint
/

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
None

### Response
#### Success Response (200)
Depends on the handler implementation.

#### Response Example
None
```

--------------------------------

### Rust: Create POST Request

Source: https://docs.rs/rovo/latest/rovo/extract/type.Request_search=std%3A%3Avec

Provides an example of creating an HTTP POST request with `Request::post()`. It sets the URI and method to POST. The request is then built and unwrapped.

```Rust
let request = Request::post("https://www.rust-lang.org/")
    .body(()) 
    .unwrap();
```

--------------------------------

### GET /api/route

Source: https://docs.rs/rovo/latest/rovo/routing/fn.get

Defines a GET route using a handler decorated with `#[rovo]`. This function is used to create a router for handling GET requests.

```APIDOC
## GET /api/route

### Description
Create a GET route with documentation from a `#[rovo]` decorated handler.

### Method
GET

### Endpoint
/api/route

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```json
{
  "example": "No request body for GET"
}
```

### Response
#### Success Response (200)
- **(type)** - Description of the response data structure.

#### Response Example
```json
{
  "example": "Response data from the handler"
}
```
```

--------------------------------

### Create ApiMethodRouter Instance

Source: https://docs.rs/rovo/latest/rovo/struct.ApiMethodRouter

Demonstrates the creation of a new `ApiMethodRouter` instance. This is a foundational step before chaining handlers.

```rust
pub const fn new(inner: ApiMethodRouter<S>) -> Self
```

--------------------------------

### POST /route

Source: https://docs.rs/rovo/latest/rovo/routing/fn.post_search=

Creates a POST route with documentation from a `#[rovo]` decorated handler.

```APIDOC
## POST /route

### Description
Creates a POST route with documentation from a `#[rovo]` decorated handler.

### Method
POST

### Endpoint
/route

### Parameters

#### Query Parameters
- **handler** (H) - Required - The handler function to be used for this route.

### Request Body
This endpoint does not explicitly define a request body schema in the provided documentation. The handler function `H` will define the expected input.

### Response
#### Success Response (200)
- **ApiMethodRouter** (ApiMethodRouter<S>) - A router instance configured for the POST method.

#### Response Example
```json
{
  "message": "Route created successfully"
}
```
```

--------------------------------

### Create GET Route with Handler in Rust

Source: https://docs.rs/rovo/latest/rovo/routing/fn.get

Creates a GET route using the `get` function from `rovo::routing`. This function takes a handler that can be converted into an `ApiMethodRouter`. The handler's associated state `S` must implement `Clone`, `Send`, and `Sync`, and be `'static`.

```rust
pub fn get<S, H>(handler: H) -> ApiMethodRouter<S>
where
    H: IntoApiMethodRouter<S>,
    S: Clone + Send + Sync + 'static,

```

--------------------------------

### Implement SSE Handler with Axum and Tokio Stream

Source: https://docs.rs/rovo/latest/rovo/response/sse/index_search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

This example demonstrates how to create a Server-Sent Events (SSE) endpoint using the Axum web framework and tokio_stream. It sets up a route that streams 'hi!' events every second and configures keep-alive messages. Dependencies include axum, tokio_stream, and futures_util.

```rust
use axum::
    Router,
    routing::get,
    response::sse::{Event, KeepAlive, Sse},
;
use std::
    time::Duration,
    convert::Infallible
;
use tokio_stream::StreamExt as _ ;
use futures_util::stream::{self, Stream};

let app = Router::new().route("/sse", get(sse_handler));

async fn sse_handler() -> Sse<impl Stream<Item = Result<Event, Infallible>>> {
    // A `Stream` that repeats an event every second
    let stream = stream::repeat_with(|| Event::default().data("hi!"))
        .map(Ok)
        .throttle(Duration::from_secs(1));

    Sse::new(stream).keep_alive(KeepAlive::default())
}
```

--------------------------------

### Rovo Routing Functions (GET)

Source: https://docs.rs/rovo/latest/rovo/routing/index_search=

Function to create a GET route with documentation automatically generated from a #[rovo] decorated handler.

```rust
get
```

--------------------------------

### DefaultBodyLimit Extractor Example

Source: https://docs.rs/rovo/latest/rovo/extract/struct.DefaultBodyLimit_search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

This example demonstrates how to use `DefaultBodyLimit` to create an extractor that limits the request body to 1 kilobyte.

```APIDOC
## POST /example

### Description
An extractor similar to `Bytes`, but limiting the body to 1 KB.

### Method
POST

### Endpoint
/example

### Parameters
#### Query Parameters
None

#### Request Body
- **bytes** (Bytes) - Required - The request body content, limited to 1024 bytes.

### Request Example
```rust
use axum::{
    extract::DefaultBodyLimit,
    body::Bytes,
};

// Assuming DefaultBodyLimit has been configured to limit to 1024 bytes
async fn handle_request(axum::extract::State(bytes): DefaultBodyLimit<Bytes>) -> String {
    format!("Received {} bytes", bytes.len())
}
```

### Response
#### Success Response (200)
- **message** (String) - A confirmation message indicating the number of bytes received.

#### Response Example
```json
{
  "message": "Received 1024 bytes"
}
```
```

--------------------------------

### Rust: Create HEAD Request

Source: https://docs.rs/rovo/latest/rovo/extract/type.Request_search=std%3A%3Avec

Provides an example of creating an HTTP HEAD request using `Request::head()`. It sets the method to HEAD and specifies a URI. The request is then constructed and unwrapped.

```Rust
let request = Request::head("https://www.rust-lang.org/")
    .body(()) 
    .unwrap();
```

--------------------------------

### GET /websites/rs_rovo_rovo

Source: https://docs.rs/rovo/latest/rovo/routing/fn.get_search=u32+-%3E+bool

Creates a GET route with documentation from a handler decorated with `#[rovo]`. This function is part of the rovo::routing module.

```APIDOC
## GET /websites/rs_rovo_rovo

### Description
Creates a GET route with documentation from a `#[rovo]` decorated handler.

### Method
GET

### Endpoint
/websites/rs_rovo_rovo

### Parameters

#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```json
{}
```

### Response
#### Success Response (200)
Details depend on the handler implementation.

#### Response Example
```json
{
  "example": "response body"
}
```
```

--------------------------------

### Rust Search Example: Type Conversion

Source: https://docs.rs/rovo/latest/rovo/extract/rejection/struct.NestedPathRejection_search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

This example demonstrates a search query for type conversion in Rust, specifically from `u32` to `bool`.

```rust
u32 -> bool
```

--------------------------------

### From Trait Implementations

Source: https://docs.rs/rovo/latest/rovo/response/struct.Extension_search=std%3A%3Avec

Documentation for methods available through the `From` trait.

```APIDOC
## From<T>

### Description
Provides conversion from one type to another.

### Methods
#### fn from(t: T) -> T
Returns the argument unchanged.
```

--------------------------------

### Get Scheme as String from a URI

Source: https://docs.rs/rovo/latest/rovo/extract/struct.OriginalUri_search=

Demonstrates how to get the URI scheme as a string slice. Similar to `scheme()`, this returns None for relative URIs.

```rust
use http::Uri;

let uri: Uri = "http://example.org/hello/world".parse().unwrap();

assert_eq!(uri.scheme_str(), Some("http"));

let uri_relative: Uri = "/hello/world".parse().unwrap();

assert!(uri_relative.scheme_str().is_none());
```

--------------------------------

### Rust Search Example: std::vec

Source: https://docs.rs/rovo/latest/rovo/extract/rejection/struct.NestedPathRejection_search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

This is an example search query for documentation related to the standard library's `Vec` type in Rust.

```rust
std::vec
```

--------------------------------

### Rust: Create OPTIONS Request Shortcut

Source: https://docs.rs/rovo/latest/rovo/extract/type.Request_search=

Provides a convenient shortcut `Request::options()` for creating an OPTIONS request with a specified URI. The builder is initialized with the OPTIONS method and the provided URI.

```rust
let request = Request::options("https://www.rust-lang.org/")
    .body(())
    .unwrap();

```

--------------------------------

### CloneToUninit Trait Implementation

Source: https://docs.rs/rovo/latest/rovo/response/struct.Extension_search=

Documentation for the experimental `clone_to_uninit` method for types implementing `Clone`.

```APIDOC
## CloneToUninit

### Description
Performs copy-assignment from `self` to a destination pointer. This is a nightly-only experimental API.

### Method
`clone_to_uninit`

### Endpoint
N/A (Trait method)

### Parameters
- **dest** (*mut u8) - A mutable pointer to the destination memory location.

### Request Example
None

### Response
None (This is an unsafe operation and does not return a value directly).
```

--------------------------------

### Chain GET HTTP Method Handler with ApiMethodRouter

Source: https://docs.rs/rovo/latest/rovo/struct.ApiMethodRouter

Shows how to append a GET request handler to an `ApiMethodRouter`. The handler needs to be convertible into an `ApiMethodRouter` compatible type.

```rust
pub fn get<H>(self, handler: H) -> Self
where H: IntoApiMethodRouter<S>
```

--------------------------------

### Convert Handler to MakeService (With Connection Info)

Source: https://docs.rs/rovo/latest/rovo/response/struct.Redirect_search=

Converts a handler into a `MakeService` that includes connection information, while still maintaining no state.

```APIDOC
## POST /websites/rs_rovo_rovo/into_make_service_with_connect_info

### Description
Converts the handler into a `MakeService` which stores information about the incoming connection and has no state.

### Method
POST

### Endpoint
`/websites/rs_rovo_rovo/into_make_service_with_connect_info`

### Parameters

#### Query Parameters
- **C** (ConnectInfoType) - Required - The type of connection information to store.

#### Request Body
- **self** (HandlerService<H, T, ()>) - Required - The handler service to convert.

### Response
#### Success Response (200)
- **IntoMakeServiceWithConnectInfo<HandlerService<H, T, ()>, C>** - The converted `MakeService` with connection info.

### Response Example
```json
{
  "message": "Handler converted to MakeService with connect info successfully"
}
```
```

--------------------------------

### GET /users/{id} - Get User

Source: https://docs.rs/rovo/latest/rovo/extract/struct.Json_search=std%3A%3Avec

This endpoint shows how to use the `Json` response type to serialize a `User` struct into a JSON response.

```APIDOC
## GET /users/{id}

### Description
This endpoint retrieves user information by ID and returns it as a JSON response.

### Method
GET

### Endpoint
/users/{id}

### Parameters
#### Path Parameters
- **id** (uuid) - Required - The unique identifier of the user.

### Request Example
(No specific request example provided in the source text for this endpoint.)

### Response
#### Success Response (200)
- **id** (uuid) - The unique identifier of the user.
- **username** (string) - The username of the user.

#### Response Example
```json
{
  "id": "a1b2c3d4-e5f6-7890-1234-567890abcdef",
  "username": "john_doe"
}
```
```

--------------------------------

### Apply multiple extractors

Source: https://docs.rs/rovo/latest/rovo/extract/index_search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Demonstrates how to use multiple extractors within a single handler function. This example combines `Path` for extracting user ID from the URL and `Query` for pagination parameters.

```rust
use axum::extract::{Path, Query};
use uuid::Uuid;
use serde::Deserialize;

#[derive(Deserialize)]
struct Pagination {
    page: usize,
    per_page: usize,
}

async fn get_user_things(
    Path(user_id): Path<Uuid>,
    Query(pagination): Query<Pagination>,
) {
    // ...
}

```

--------------------------------

### Create GET Request with Builder (Rust)

Source: https://docs.rs/rovo/latest/rovo/extract/type.Request_search=u32+-%3E+bool

Initializes a request builder with the GET method and a specified URI. The body is set to an empty tuple, and the request is unwrapped.

```rust
let request = Request::get("https://www.rust-lang.org/")
    .body(())
    .unwrap();
```

--------------------------------

### TryFrom Trait Implementations

Source: https://docs.rs/rovo/latest/rovo/response/struct.Extension_search=std%3A%3Avec

Documentation for methods available through the `TryFrom` trait.

```APIDOC
## TryFrom<U>

### Description
Provides fallible conversion from one type to another.

### Type Aliases
#### type Error = Infallible
The type returned in the event of a conversion error.

### Methods
#### fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
Performs the conversion.
```

--------------------------------

### Get Path and Query Components of a URI

Source: https://docs.rs/rovo/latest/rovo/extract/struct.OriginalUri_search=

Demonstrates retrieving the path and query components of a URI. This method returns an Option<&PathAndQuery>, which can be further processed to get specific parts of the URI.

```rust
use http::Uri;

let uri: Uri = "/hello/world?key=value".parse().unwrap();

assert_eq!(uri.path_and_query().map(|pq| pq.as_str()), Some("/hello/world?key=value"));
```

--------------------------------

### Configure OpenAPI with Custom Base Route

Source: https://docs.rs/rovo/latest/rovo/struct.Router

This example shows how to configure the OpenAPI specification for the Rovo Router using a custom base route. It sets up endpoints for JSON and YAML documentation at the specified custom path.

```rust
# use rovo::{Router, aide::openapi::OpenApi};
# #[tokio::main]
# async fn main() {
# let api = OpenApi::default();
let router = Router::new().with_oas_route(api, "/openapi");
# }
```

--------------------------------

### Error Example: Type 'u32' not found

Source: https://docs.rs/rovo/latest/rovo/extract/trait.OptionalFromRequest_search=u32+-%3E+bool

An example of a potential error where the type 'u32' is not found and used as a generic parameter, specifically in the context of rovo::extract::path::ErrorKind::equivalent.

```APIDOC
## Error: Type 'u32' not found

### Description
Type "u32" not found and used as generic parameter.

### Method
`rovo::extract::path::ErrorKind::equivalent`

### Signature
`&, &**K** -> **bool**`

### Constraints
`u32` matches `**K**`
```

--------------------------------

### TryInto Trait Implementations

Source: https://docs.rs/rovo/latest/rovo/response/struct.Extension_search=std%3A%3Avec

Documentation for methods available through the `TryInto` trait.

```APIDOC
## TryInto<U>

### Description
Provides fallible conversion into another type.

### Type Aliases
#### type Error = <U as TryFrom<T>>::Error
The type returned in the event of a conversion error.

### Methods
#### fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
Performs the conversion.
```

--------------------------------

### IntoApiMethodRouter: Convert to GET Route - Rust

Source: https://docs.rs/rovo/latest/rovo/trait.IntoApiMethodRouter

Converts a handler into a documented GET route using the IntoApiMethodRouter trait. This method is part of the interface provided by the rovo library for API routing.

```rust
fn into_get_route(self) -> ApiMethodRouter<S>
```

--------------------------------

### Get Underlying Error Kind from FailedToDeserializePathParams in Rust

Source: https://docs.rs/rovo/latest/rovo/extract/path/struct.FailedToDeserializePathParams_search=u32+-%3E+bool

Provides a method to get a reference to the underlying ErrorKind from a FailedToDeserializePathParams instance. This is useful for inspecting the specific reason for deserialization failure.

```rust
pub fn kind(&self) -> &ErrorKind
```

--------------------------------

### POST /delete

Source: https://docs.rs/rovo/latest/rovo/routing/fn.delete_search=std%3A%3Avec

Create a DELETE route with documentation from a #[rovo] decorated handler.

```APIDOC
## POST /delete

### Description
Create a DELETE route with documentation from a `#[rovo]` decorated handler.

### Method
POST

### Endpoint
/delete

### Parameters

#### Query Parameters
- **handler** (H) - Required - The handler to be used for the DELETE route.

### Request Body
This endpoint does not explicitly define a request body in the provided documentation.

### Response
#### Success Response (200)
- **ApiMethodRouter** (ApiMethodRouter<S>) - Returns an ApiMethodRouter configured with the DELETE route.

#### Response Example
```json
{
  "message": "DELETE route created successfully"
}
```
```

--------------------------------

### Create New ApiRouter

Source: https://docs.rs/rovo/latest/rovo/axum/struct.ApiRouter_search=std%3A%3Avec

Initializes a new ApiRouter instance. This is analogous to `axum::Router::new()`.

```rust
pub fn new() -> ApiRouter<S>
```

--------------------------------

### Example: Using RawQuery Extractor in Axum

Source: https://docs.rs/rovo/latest/rovo/extract/struct.RawQuery_search=u32+-%3E+bool

Demonstrates how to use the RawQuery extractor within an Axum handler to access the raw query string. It shows the necessary imports and how to define a simple Axum router.

```rust
use axum {
    extract::RawQuery,
    routing::get,
    Router,
};
use futures_util::StreamExt;

async fn handler(RawQuery(query): RawQuery) {
    // ...
}

let app = Router::new().route("/users", get(handler));
```

--------------------------------

### FromRef Implementation Example (Rust)

Source: https://docs.rs/rovo/latest/rovo/extract/trait.FromRef_search=

An example implementation of the FromRef trait for type T where T must implement the Clone trait. This shows a common scenario where a type can be converted from a reference to itself if it's cloneable.

```rust
impl<T> FromRef<T> for T
where T: Clone
```

--------------------------------

### Handler to MakeService Conversion (Connect Info, No State) in Rust

Source: https://docs.rs/rovo/latest/rovo/response/struct.Extension_search=u32+-%3E+bool

The `into_make_service_with_connect_info` function converts a state-less handler into a `MakeService` that also captures connection information. This is useful for servers that need to know details about incoming connections.

```rust
impl<H, T> HandlerWithoutStateExt<T> for H
where H: Handler<T, ()>,
{
    fn into_make_service_with_connect_info<C>(
        self,
    ) -> IntoMakeServiceWithConnectInfo<HandlerService<H, T, ()>, C>
}
```

--------------------------------

### Define RawQuery Struct and Example Usage (Rust)

Source: https://docs.rs/rovo/latest/rovo/extract/struct.RawQuery

Defines the RawQuery struct, which holds an optional String representing the raw query. Includes an example demonstrating how to use RawQuery as an extractor in an Axum application.

```rust
pub struct RawQuery(pub Option<String>);
```

```rust
use axum::extract::RawQuery;

async fn handler(RawQuery(query): RawQuery) {
    // ...
}
```

--------------------------------

### ApiRouter Initialization and State Management

Source: https://docs.rs/rovo/latest/rovo/axum/struct.ApiRouter_search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Methods for creating a new `ApiRouter` and managing its associated state.

```APIDOC
### impl<S> ApiRouter<S>

#### pub fn new() -> ApiRouter<S>

Create a new router. See `axum::Router::new` for details.
```

```APIDOC
#### pub fn with_state<S2>(self, state: S) -> ApiRouter<S2>

Add state to the router. See `axum::Router::with_state` for details.
```
Tokens:
Raw