Skip to content

Procedural macro to automatically generate a REST client from a trait definition.

License

Notifications You must be signed in to change notification settings

volllly/restcrab

Repository files navigation

Restcrab

crates.io docs.rs

Restcrab provides a procedural macro restcrab and a trait Restcrab for generating a REST client from a trait definition.

Usage

use std::collections::HashMap;

use serde::{Serialize, Deserialize};
use restcrab::{restcrab, Restcrab, crabs::reqwest};

#[derive(Serialize, Deserialize)]
struct Request {
  id: i32
}

#[derive(Serialize, Deserialize)]
struct Response {
  message: String
}

#[restcrab(crab = "reqwest::Reqwest")]
trait Service {
  #[restcrab(method = "GET", uri = "/empty")]
  fn uri_from_attribute();

  #[restcrab(method = "GET", uri = "/empty/{name}")]
  fn uri_with_parameter(#[parameter] name: &str);

  #[restcrab(method = "GET")]
  fn uri_from_method_name();

  #[restcrab(method = "GET", uri = "/static_header", header("Content-Type", "application/json"))]
  fn static_header();

  #[restcrab(method = "GET", uri = "/static_headers", header("Content-Type", "application/json"), header("User-Agen", "Restcrab"))]
  fn static_headers();

  #[restcrab(method = "GET", uri = "/static_query", query("some", "query"), query("another", "one"))]
  fn static_queries();

  #[restcrab(method = "POST", uri = "/static_body", body = "0")]
  fn static_body() -> String;

  #[restcrab(method = "POST", uri = "/dynamic_headers")]
  fn dynamic_headers(#[headers] headers: HashMap<String, String>) -> String;

  #[restcrab(method = "POST", uri = "/dynamic_queries")]
  fn dynamic_queries(#[queries] queries: HashMap<String, String>) -> String;

  #[restcrab(method = "POST", uri = "/dynamic_headers", header("Content-Type", "application/json"))]
  fn both_headers(#[headers] headers: HashMap<String, String>) -> String;

  #[restcrab(method = "POST", uri = "/dynamic_body")]
  fn dynamic_body(#[body] body: Request) -> Response;
}

fn main() {
  let client = ServiceClient::from_options(reqwest::Options {
    base_url: "https://service.url".parse().unwrap()
  }).unwrap(); 

  let mut headers = HashMap::new();
  headers.insert("User-Agent".to_string(), "Restcrab".to_string());

  let mut queries = HashMap::new();
  queries.insert("key".to_string(), "value".to_string());

  let uri_from_attribute:   ()        = client.uri_from_attribute().unwrap();
  let uri_from_method_name: ()        = client.uri_from_method_name().unwrap();
  let uri_with_parameter:   ()        = client.uri_with_parameter("value").unwrap();
  let static_header:        ()        = client.static_header().unwrap();
  let static_headers:       ()        = client.static_headers().unwrap();
  let static_queries:       ()        = client.static_queries().unwrap();
  let static_body:          String    = client.static_body().unwrap();
  let dynamic_headers:      String    = client.dynamic_headers(headers.clone()).unwrap();
  let dynamic_queries:      String    = client.dynamic_queries(queries).unwrap();
  let both_headers:         String    = client.both_headers(headers).unwrap();
  let dynamic_body:         Response  = client.dynamic_body(Request { id: 0 }).unwrap();
}

Modular Backends (crabs)

Because I like to use unhelpful terminology a backend for restcrab is called a crab.

Types which implement the Restcrab trait can be used as crabs.

The crate provides one crab which uses the Reqwest http client.

If you want to implement your own crab please look at the provided implementation as starting off point