feat: can get actual available roots

Signed-off-by: kjuulh <contact@kjuulh.io>

crates/hyperlog-server/src/external_grpc.rs

@@ -225,9 +225,22 @@ impl Graph for Server {
         let req = request.into_inner();
         tracing::trace!("get available roots: req({:?})", req);
 
-        Ok(Response::new(GetAvailableRootsResponse {
+        let roots = match self
-            roots: vec!["kjuulh".into()],
+            .querier
-        }))
+            .get_available_roots()
+            .await
+            .map_err(to_tonic_err)?
+        {
+            Some(roots) => roots,
+            None => {
+                return Err(tonic::Status::new(
+                    tonic::Code::NotFound,
+                    "failed to find any valid roots",
+                ))
+            }
+        };
+
+        Ok(Response::new(GetAvailableRootsResponse { roots }))
     }
 }
 

crates/hyperlog-server/src/querier.rs

@@ -1,17 +1,32 @@
 use hyperlog_core::log::GraphItem;
 
-use crate::state::SharedState;
+use crate::{
+    services::get_available_roots::{self, GetAvailableRoots, GetAvailableRootsExt},
+    state::SharedState,
+};
 
-pub struct Querier {}
+pub struct Querier {
+    get_available_roots: GetAvailableRoots,
+}
 
-#[allow(dead_code, unused_variables)]
 impl Querier {
-    pub fn new() -> Self {
+    pub fn new(get_available_roots: GetAvailableRoots) -> Self {
-        Self {}
+        Self {
+            get_available_roots,
+        }
     }
 
-    pub fn get_available_roots(&self) -> Option<Vec<String>> {
+    pub async fn get_available_roots(&self) -> anyhow::Result<Option<Vec<String>>> {
-        todo!()
+        let res = self
+            .get_available_roots
+            .execute(get_available_roots::Request {})
+            .await?;
+
+        if res.roots.is_empty() {
+            return Ok(None);
+        }
+
+        Ok(Some(res.roots))
     }
 
     pub fn get(
@@ -29,6 +44,6 @@ pub trait QuerierExt {
 
 impl QuerierExt for SharedState {
     fn querier(&self) -> Querier {
-        Querier::new()
+        Querier::new(self.get_available_roots_service())
     }
 }

crates/hyperlog-server/src/services.rs

@@ -1,3 +1,5 @@
 pub mod create_item;
 pub mod create_root;
 pub mod create_section;
+
+pub mod get_available_roots;

crates/hyperlog-server/src/services/get_available_roots.rs

@@ -0,0 +1,54 @@
+use hyperlog_core::log::{GraphItem, ItemState};
+use sqlx::types::Json;
+
+use crate::state::SharedState;
+
+#[derive(Clone)]
+pub struct GetAvailableRoots {
+    db: sqlx::PgPool,
+}
+
+pub struct Request {}
+pub struct Response {
+    pub roots: Vec<String>,
+}
+
+#[derive(sqlx::FromRow)]
+pub struct Root {
+    root_name: String,
+}
+
+impl GetAvailableRoots {
+    pub fn new(db: sqlx::PgPool) -> Self {
+        Self { db }
+    }
+
+    pub async fn execute(&self, req: Request) -> anyhow::Result<Response> {
+        let roots: Vec<Root> = sqlx::query_as(
+            r#"
+    SELECT
+        *
+    FROM
+        roots
+    LIMIT
+        100
+            "#,
+        )
+        .fetch_all(&self.db)
+        .await?;
+
+        Ok(Response {
+            roots: roots.into_iter().map(|i| i.root_name).collect(),
+        })
+    }
+}
+
+pub trait GetAvailableRootsExt {
+    fn get_available_roots_service(&self) -> GetAvailableRoots;
+}
+
+impl GetAvailableRootsExt for SharedState {
+    fn get_available_roots_service(&self) -> GetAvailableRoots {
+        GetAvailableRoots::new(self.db.clone())
+    }
+}