rustify

A Rust library for interacting with HTTP API endpoints

Rustify is a small library written in Rust which eases the burden of scaffolding HTTP APIs. It provides an Endpoint trait along with a macro helper which allows templating various remote endpoints. Both asynchronous and synchronous clients are offered for executing requests against endpoints with the option of implementing custom clients using the Client trait.

Rustify provides support for serializing requests and deserializing responses. Raw requests and responses in the form of bytes are also supported. The library also contains many helpers for dealing with requests like support for middleware and wrapping API responses.

Installation

Add rustify as a dependency to your cargo.toml:

[dependencies]
rustify = "0.6.1"rustify_derive = "0.5.4"

Usage

Basic

use rustify::{Client,Endpoint};use rustify_derive::Endpoint;// Defines an API endpoint at /test/path that takes no inputs and returns an// empty response.#[derive(Endpoint)]#[endpoint(path = "test/path")]structTest{}let endpoint = Test{};let client = Client::default("http://api.com");// Configures base address of http://api.comlet result = endpoint.exec(&client).await;// Sends GET request to http://api.com/test/pathassert!(result.is_ok());

Request Body

use derive_builder::Builder;use rustify::{Client,Endpoint};use rustify_derive::Endpoint;// Defines an API endpoint at /test/path/{name} that takes one input for// creating the url and two inputs for building the request body. The content// type of the request body defaults to JSON, however, it can be modified by// passing the `request_type` parameter to the endpoint configuration.//// Note: The `#[endpoint(body)]` attribute tags are technically optional in the// below example. If no `body` attribute is found anywhere then rustify defaults// to serializing all "untagged" fields as part of the body. Fields can be opted// out of this behavior by tagging them with #[endpoint(skip)].#[derive(Builder,Endpoint)]#[endpoint(path = "test/path/{self.name}", method = "POST", builder = "true")]#[builder(setter(into))]// Improves the building processstructTest{#[endpoint(skip)]// This field shouldn't be serialized anywherepubname:String,// Used to create a dynamic URL#[endpoint(body)]// Instructs rustify to serialize this field as part of the bodypubage:i32,#[endpoint(body)]pubrole:String,}// Setting `builder` to true creates a `builder()` method on our struct that// returns the TestBuilder type created by `derive_builder`.let endpoint = Test::builder().name("jmgilman").age(42).role("CEO").build().unwrap();let client = Client::default("http://api.com");let result = endpoint.exec(&client).await;// Sends POST request to http://api.com/test/path/jmgilmanassert!(result.is_ok());

Query Parameters

use derive_builder::Builder;use rustify::{Client,Endpoint};use rustify_derive::Endpoint;// Defines a similar API endpoint as in the previous example but adds an// optional query parameter to the request. Additionally, this example opts to// not specify the `#[endpoint(body)]` attributes to make use of the default// behavior covered in the previous example.#[derive(Builder,Endpoint)]#[endpoint(path = "test/path/{self.name}", method = "POST", builder = "true")]#[builder(setter(into, strip_option),default)]// Improves building processstructTest{#[endpoint(skip)]pubname:String,#[endpoint(query)]pubscope:Option<String>,// Note: serialization is skipped when this field is Nonepubage:i32,// Serialized into the request bodypubrole:String,// Serialized into the request body}let endpoint = Test::builder().name("jmgilman").scope("global").age(42).role("CEO").build().unwrap();let client = Client::default("http://api.com");let result = endpoint.exec(&client).await;// Sends POST request to http://api.com/test/path/jmgilman?scope=globalassert!(result.is_ok());

Responses

use rustify::{Client,Endpoint};use rustify_derive::Endpoint;// Defines an API endpoint at /test/path that takes a single byte array which// will be used as the request body (no serialization occurs). The endpoint// returns a `TestResponse` which contains the result of the operation.#[derive(Endpoint)]#[endpoint(path = "test/path", response = "TestResponse")]structTest{#[endpoint(raw)]// Indicates this field contains the raw request bodypubfile:Vec<u8>}#[derive(Deserialize)]structTestResponse{pubsuccess:bool,}let endpoint = Test{file:b"contents".to_vec(),};let client = Client::default("http://api.com");let result = endpoint.exec(&client).await;assert!(result.is_ok());let response = result.unwrap().parse().unwrap();// Returns the parsed `TestResponse`dbg!(response.success);

Examples

You can find example usage in the examples directory. They can be run with cargo:

cargo run --package rustify --example reqres1
cargo run --package rustify --example reqres2

The vaultrs crate is built upon rustify and serves as as good reference.

Features

The following features are available for this crate:

• blocking: Enables the blocking variants of Clients as well as the blocking exec() functions in Endpoints.

Error Handling

All errors generated by this crate are wrapped in the ClientError enum provided by the crate.

Testing

See the the tests directory for tests. Run tests with cargo test.

Contributing

Check out the issues for items needing attention or submit your own and then:

1. Fork it (https://github.com/jmgilman/rustify/fork)
2. Create your feature branch (git checkout -b feature/fooBar)
3. Commit your changes (git commit -am 'Add some fooBar')
4. Push to the branch (git push origin feature/fooBar)
5. Create a new Pull Request