feat(proxy): demo warp based REST API endpoints

proxy/src/coco.rs

@@ -420,18 +420,17 @@ pub fn init_project(
     name: &str,
     description: &str,
     default_branch: &str,
-    img_url: &str,
+    img_url: Url,
 ) -> Result<(git::ProjectId, meta::Project), error::Error> {
     let key = keys::device::Key::new();
     let peer_id = peer::PeerId::from(key.public());
     let founder = meta::contributor::Contributor::new();
     let sources = git2::Repository::open(std::path::Path::new(path))?;
-    let img = Url::parse(img_url)?;
     let mut meta = meta::Project::new(name, &peer_id);
 
     meta.description = Some(description.to_string());
     meta.default_branch = default_branch.to_string();
-    meta.add_rel(meta::Relation::Url("img_url".to_string(), img));
+    meta.add_rel(meta::Relation::Url("img_url".to_string(), img_url));
 
     let id = git::GitProject::init(librad_paths, &key, &sources, meta.clone(), founder)?;
 
@@ -477,7 +476,7 @@ pub fn replicate_platinum(
     name: &str,
     description: &str,
     default_branch: &str,
-    img_url: &str,
+    img_url: Url,
 ) -> Result<(git::ProjectId, meta::Project), error::Error> {
     // Craft the absolute path to git-platinum fixtures.
     let mut platinum_path = env::current_dir()?;
@@ -564,25 +563,25 @@ pub fn setup_fixtures(librad_paths: &Paths, root: &str) -> Result<(), error::Err
                 "monokel",
                 "A looking glass into the future",
                 "master",
-                "https://res.cloudinary.com/juliendonck/image/upload/v1557488019/Frame_2_bhz6eq.svg",
+                Url::parse("https://res.cloudinary.com/juliendonck/image/upload/v1557488019/Frame_2_bhz6eq.svg")?,
             ),
             (
                 "Monadic",
                 "Open source organization of amazing things.",
                 "master",
-                "https://res.cloudinary.com/juliendonck/image/upload/v1549554598/monadic-icon_myhdjk.svg",
+                Url::parse("https://res.cloudinary.com/juliendonck/image/upload/v1549554598/monadic-icon_myhdjk.svg")?,
             ),
             (
                 "open source coin",
                 "Research for the sustainability of the open source community.",
                 "master",
-                "https://avatars0.githubusercontent.com/u/31632242",
+                Url::parse("https://avatars0.githubusercontent.com/u/31632242")?,
             ),
             (
                 "radicle",
                 "Decentralized open source collaboration",
                 "master",
-                "https://avatars0.githubusercontent.com/u/48290027",
+                Url::parse("https://avatars0.githubusercontent.com/u/48290027")?,
             ),
         ];
 

proxy/src/graphql/schema.rs

@@ -3,6 +3,7 @@ use std::convert::TryFrom;
 use std::str::FromStr;
 use std::sync;
 
+use librad::meta::Url;
 use librad::paths::Paths;
 use librad::surf;
 use librad::surf::git::git2;
@@ -89,7 +90,7 @@ impl Mutation {
             &metadata.name,
             &metadata.description,
             &metadata.default_branch,
-            &metadata.img_url,
+            Url::parse(&metadata.img_url)?,
         )?;
 
         Ok(project::Project {
@@ -368,7 +369,7 @@ impl ControlMutation {
             &metadata.name,
             &metadata.description,
             &metadata.default_branch,
-            &metadata.img_url,
+            Url::parse(&metadata.img_url)?,
         )?;
 
         Ok(project::Project {

proxy/src/http.rs

@@ -0,0 +1,38 @@
+//! HTTP API delivering JSON over `RESTish` endpoints.
+
+use librad::paths;
+use std::convert::Infallible;
+use std::sync::Arc;
+use tokio::sync::RwLock;
+use warp::{path, Filter};
+
+use crate::registry;
+
+mod error;
+mod project;
+
+/// Main entry point for HTTP API.
+pub async fn run(librad_paths: paths::Paths, reg: registry::Registry) {
+    let api = path("v1").and(
+        project::filters(librad_paths.clone(), Arc::new(RwLock::new(reg))).recover(error::recover),
+    );
+
+    // TODO(xla): Pass down as configuration with sane defaults.
+    warp::serve(api).run(([127, 0, 0, 1], 8090)).await;
+}
+
+/// State filter to expose the [`librad::paths::Paths`] to handlers.
+#[must_use]
+pub fn with_paths(
+    paths: paths::Paths,
+) -> impl Filter<Extract = (paths::Paths,), Error = Infallible> + Clone {
+    warp::any().map(move || paths.clone())
+}
+
+/// State filter to expose the [`registry::Registry`] to handlers.
+#[must_use]
+pub fn with_registry(
+    reg: Arc<RwLock<registry::Registry>>,
+) -> impl Filter<Extract = (Arc<RwLock<registry::Registry>>,), Error = Infallible> + Clone {
+    warp::any().map(move || Arc::<RwLock<registry::Registry>>::clone(&reg))
+}

proxy/src/http/error.rs

@@ -0,0 +1,104 @@
+//! Recovery and conversion of [`error::Error`] to proper JSON responses, which expose variants
+//! for API consumers to act on.
+
+use std::convert::Infallible;
+use warp::http::StatusCode;
+use warp::{reject, reply, Rejection, Reply};
+
+use crate::error;
+
+impl reject::Reject for error::Error {}
+
+impl From<error::Error> for Rejection {
+    fn from(err: error::Error) -> Self {
+        reject::custom(err)
+    }
+}
+
+/// Error type to carry context for failed requests.
+#[derive(serde_derive::Serialize)]
+struct Error {
+    /// Human readable message to convery error case.
+    message: String,
+    /// The triggered error variant.
+    variant: String,
+}
+
+/// Handler to convert [`error::Error`] to [`Error`] response.
+pub async fn recover(err: Rejection) -> Result<impl Reply, Infallible> {
+    let (code, variant, message) = {
+        if err.is_not_found() {
+            (StatusCode::NOT_FOUND, "NOT_FOUND", "Resource not found")
+        } else if let Some(err) = err.find::<error::Error>() {
+            match err {
+                _ => {
+                    // TODO(xla): Match all variants and properly transform similar to
+                    // gaphql::error.
+                    (StatusCode::BAD_REQUEST, "BAD_REQUEST", "Incorrect input")
+                },
+            }
+        } else {
+            (
+                StatusCode::INTERNAL_SERVER_ERROR,
+                "INTERNAL_ERROR",
+                "Something went wrong",
+            )
+        }
+    };
+    let res = reply::json(&Error {
+        message: message.to_string(),
+        variant: variant.to_string(),
+    });
+
+    Ok(reply::with_status(res, code))
+}
+
+#[cfg(test)]
+mod tests {
+    use futures::stream::TryStreamExt;
+    use pretty_assertions::assert_eq;
+    use serde_json::{json, Value};
+    use warp::reply::Reply as _;
+    use warp::Rejection;
+
+    #[tokio::test]
+    async fn recover_custom() {
+        let have: Value = response(warp::reject::custom(
+            crate::error::Error::InordinateString32(),
+        ))
+        .await;
+        let want = json!({
+            "message": "Incorrect input",
+            "variant": "BAD_REQUEST",
+        });
+
+        assert_eq!(have, want);
+    }
+
+    #[tokio::test]
+    async fn recover_not_found() {
+        let have: Value = response(warp::reject::not_found()).await;
+        let want = json!({
+            "message": "Resource not found",
+            "variant": "NOT_FOUND",
+        });
+
+        assert_eq!(have, want);
+    }
+
+    async fn response(err: Rejection) -> Value {
+        let res = super::recover(err).await.unwrap();
+
+        let body = res
+            .into_response()
+            .body_mut()
+            .try_fold(Vec::new(), |mut data, chunk| async move {
+                data.extend_from_slice(&chunk);
+                Ok(data)
+            })
+            .await
+            .unwrap();
+
+        serde_json::from_slice(&body).unwrap()
+    }
+}