wip: reference and oject endpoints

DESIGN.md

@@ -90,7 +90,7 @@ operations.
 
 ### Bootstrapping
 
-* Load `/api/v1/resource/all/<username>` and then follow the sub resources to
+* Load `/api/v1/ref/all/<username>` and then follow the sub resources to
   load the entire dataset locally making sure to keep the content-addresses
   around for comparison.
 

src/datamodel/mod.rs

@@ -5,15 +5,17 @@ use serde::{Serialize, Deserialize};
 #[derive(Serialize, Deserialize)]
 pub struct Reference {
     object_id: String,
+    content_address: String,
     path: String,
     #[serde(skip_serializing_if = "Vec::is_empty")]
     dependents: Vec<Rc<Reference>>,
 }
 
 impl Reference {
-    pub fn new(object_id: String, path: String) -> Self {
+    pub fn new(object_id: String, content_address: String, path: String) -> Self {
         Self {
             object_id,
+            content_address,
             path,
             dependents: Vec::new(),
         }

src/lib.rs

@@ -1,24 +1,90 @@
 use std::rc::Rc;
 
-use axum::{
+use axum::{extract::Path, routing::get, Json, Router};
-    routing::get,
-    Router,
-    Json,
-};
 use datamodel::Reference;
 
 mod datamodel;
 
 async fn all_references() -> Json<Rc<Reference>> {
-    Json(datamodel::Reference::new("silly id".to_string(), "all/username".to_string()).to_rc())
+    let path_root = String::from("ref/0");
+    let mut root_ref = Reference::new(
+        "username:0".to_string(),
+        String::from("0"),
+        path_root.clone(),
+    );
+    for i in 1..=10 {
+        let mut item_ref = Reference::new(
+            format!("item:{}", i),
+            format!("0:{}", i),
+            format!("{}/item/{}", path_root, i),
+        );
+        for j in 1..=10 {
+            item_ref = item_ref.add_dep(Rc::new(Reference::new(
+                format!("item:{}:subitem:{}", i, j),
+                format!("0:{}:{}", i, j),
+                format!("{}/item/{}/subitem/{}", path_root, i, j),
+            )));
+        }
+        root_ref = root_ref.add_dep(Rc::new(item_ref));
+    }
+    Json(root_ref.to_rc())
+}
+
+async fn dummy_item_ref(Path(i): Path<usize>) -> Json<Rc<Reference>> {
+    let path_root = String::from("ref/0");
+    let mut item_ref = Reference::new(
+        format!("item:{}", i),
+        format!("0:{}", i),
+        format!("{}/item/{}", path_root, i),
+    );
+    for j in 1..=10 {
+        item_ref = item_ref.add_dep(Rc::new(Reference::new(
+            format!("item:{}:subitem:{}", i, j),
+            format!("0:{}:{}", i, j),
+            format!("{}/item/{}/subitem/{}", path_root, i, j),
+        )));
+    }
+    Json(item_ref.to_rc())
+}
+
+async fn dummy_subitem_ref(Path(i): Path<usize>, Path(j): Path<usize>) -> Json<Rc<Reference>> {
+    let path_root = String::from("ref/0");
+    Json(
+        Reference::new(
+            format!("item:{}:subitem:{}", i, j),
+            format!("0:{}:{}", i, j),
+            format!("{}/item/{}/subitem/{}", path_root, i, j),
+        )
+        .to_rc(),
+    )
+}
+
+async fn dummy_object(Path(addr): Path<String>) -> String {
+    format!("I am object {}", addr)
 }
 
 pub fn endpoints() -> Router {
-    Router::new().route("/api/v1/ref/all/username", get(all_references))
+    Router::new().nest(
+        "/api/v1",
+        Router::new().nest(
+            "/ref",
+            Router::new()
+                .route("/all/username", get(all_references))
+                .route("/item/{i}", get(dummy_item_ref))
+                .route("/item/{i}/subitem/{j}", get(dummy_subitem_ref))
+        ).nest(
+            "/object",
+            Router::new()
+                .route("/{addr}", get(dummy_object))
+        ),
+    )
 }
 
+// TODO(jwall): Javascript test script
 pub async fn serve() {
     // run our app with hyper, listening globally on port 3000
-    let listener = tokio::net::TcpListener::bind("127.0.0.1:3000").await.unwrap();
+    let listener = tokio::net::TcpListener::bind("127.0.0.1:3000")
+        .await
+        .unwrap();
     axum::serve(listener, endpoints()).await.unwrap();
 }