utoipa - Auto-generated OpenAPI documentation

Utoipa build crates.io docs.rs MSRV

Pronounced /ju:ˈtoʊ:i.pɑ/ or /ju:ˈtoʊˌaɪ.piˈeɪ/ whatever works better for you.

Want to have your API documented with OpenAPI? But don't want to be bothered with manual YAML or JSON tweaking? Would like it to be so easy that it would almost be utopic? Don't worry: utoipa is here to fill this gap. It aims to do, if not all, then most of the heavy lifting for you, enabling you to focus on writing the actual API logic instead of documentation. It aims to be minimal, simple and fast. It uses simple proc macros which you can use to annotate your code to have items documented.

The utoipa crate provides auto-generated OpenAPI documentation for Rust REST APIs. It treats code-first approach as a first class citizen and simplifies API documentation by providing simple macros for generating the documentation from your code.

It also contains Rust types of the OpenAPI spec, allowing you to write the OpenAPI spec only using Rust if auto generation is not your flavor or does not fit your purpose.

Long term goal of the library is to be the place to go when OpenAPI documentation is needed in any Rust codebase.

Utoipa is framework-agnostic, and could be used together with any web framework, or even without one. While being portable and standalone, one of its key aspects is simple integration with web frameworks.

Choose your flavor and document your API with ice-cold IPA

Refer to the existing examples for building the "todo" app in the following frameworks:

All examples include a Swagger-UI unless stated otherwise.

There are also examples of building multiple OpenAPI docs in one application, each separated in Swagger UI. These examples exist only for the actix and warp frameworks.

Even if there is no example for your favourite framework, utoipa can be used with any web framework which supports decorating functions with macros similarly to the warp and tide examples.

Community examples

What's up with the word play?

The name comes from the words utopic and api where uto are the first three letters of utopic and the ipa is api reversed. Aaand... ipa is also an awesome type of beer :beer:.

Crate Features

Utoipa implicitly has partial support for serde attributes. See docs for more details.

Install

Add minimal dependency declaration to Cargo.toml.

toml [dependencies] utoipa = "3"

To enable more features such as use actix framework extras you could define the dependency as follows.

toml [dependencies] utoipa = { version = "3", features = ["actix_extras"] }

Note! To use utoipa together with Swagger UI you can use the utoipa-swagger-ui crate.

Examples

Create a struct, or it could also be an enum. Add ToSchema derive macro to it, so it can be registered as an OpenAPI schema.

```rust use utoipa::ToSchema;

[derive(ToSchema)]

struct Pet { id: u64, name: String, age: Option, } ```

Create a handler that would handle your business logic and add path proc attribute macro over it.

rust mod pet_api { /// Get pet by id /// /// Get pet from database by pet id #[utoipa::path( get, path = "/pets/{id}", responses( (status = 200, description = "Pet found succesfully", body = Pet), (status = NOT_FOUND, description = "Pet was not found") ), params( ("id" = u64, Path, description = "Pet database id to get Pet for"), ) )] async fn get_pet_by_id(pet_id: u64) -> Pet { Pet { id: pet_id, age: None, name: "lightning".to_string(), } } } Utoipa has support for http StatusCode in responses.

This attribute macro will create another struct named with __path_ prefix + handler function name. So when you implement some_handler function in different file and want to export this, make sure __path_some_handler in the module can also be accessible from the root.

Tie the Schema and the endpoint above to the OpenAPI schema with following OpenApi derive proc macro.

```rust use utoipa::OpenApi;

[derive(OpenApi)]

[openapi(paths(petapi::getpetbyid), components(schemas(Pet)))]

struct ApiDoc;

println!("{}", ApiDoc::openapi().toprettyjson().unwrap()); ```

This would produce api doc something similar to:

json { "openapi": "3.0.3", "info": { "title": "application name from Cargo.toml", "description": "description from Cargo.toml", "contact": { "name": "author name from Cargo.toml", "email": "author email from Cargo.toml" }, "license": { "name": "license from Cargo.toml" }, "version": "version from Cargo.toml" }, "paths": { "/pets/{id}": { "get": { "tags": ["pet_api"], "summary": "Get pet by id", "description": "Get pet by id\n\nGet pet from database by pet id\n", "operationId": "get_pet_by_id", "parameters": [ { "name": "id", "in": "path", "description": "Pet database id to get Pet for", "required": true, "deprecated": false, "schema": { "type": "integer", "format": "int64", "minimum": 0.0, } } ], "responses": { "200": { "description": "Pet found succesfully", "content": { "application/json": { "schema": { "$ref": "#/components/schemas/Pet" } } } }, "404": { "description": "Pet was not found" } }, "deprecated": false } } }, "components": { "schemas": { "Pet": { "type": "object", "required": ["id", "name"], "properties": { "id": { "type": "integer", "format": "int64", "minimum": 0.0, }, "name": { "type": "string" }, "age": { "type": "integer", "format": "int32", "nullable": true, } } } } } }

## Modify OpenAPI at runtime

You can modify generated OpenAPI at runtime either via generated types directly or using Modify trait.

Modify generated OpenAPI via types directly. ```rust #[derive(OpenApi)] #[openapi( info(description = "My Api description"), )] struct ApiDoc;

let mut doc = ApiDoc::openapi(); doc.info.title = String::from("My Api"); ```

You can even convert the generated OpenApi to OpenApiBuilder. rust let builder: OpenApiBuilder = ApiDoc::openapi().into();

See Modify trait for examples on how to modify generated OpenAPI via it.

Go beyond the surface

General Pitfalls

Swagger UI returns 404 NotFound from built binary

This is highly probably due to RustEmbed not embedding the Swagger UI to the executable. This is natural since the RustEmbed library does not by default embed files on debug builds. To get around this you can do one of the following.

  1. Build your executable in --release mode
  2. or add debug-embed feature flag to your Cargo.toml for utoipa-swagger-ui. This will enable the debug-emebed feature flag for RustEmbed as well. Read more about this here and here.

Find utoipa-swagger-ui feature flags here.

License

Licensed under either of Apache 2.0 or MIT license at your option.

Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in this crate by you, shall be dual licensed, without any additional terms or conditions.