app: Migrate list_users to use the graphql client

app/src/api.rs

@@ -1,5 +1,6 @@
 use crate::cookies::set_cookie;
 use anyhow::{anyhow, Context, Result};
+use graphql_client::GraphQLQuery;
 use lldap_model::*;
 
 use yew::callback::Callback;
@@ -109,11 +110,31 @@ where
 }
 
 impl HostService {
-    pub fn list_users(
-        request: ListUsersRequest,
-        callback: Callback<Result<Vec<User>>>,
-    ) -> Result<FetchTask> {
-        call_server_json_with_error_message("/api/users", &request, callback, "")
+    pub fn graphql_query<QueryType>(
+        variables: QueryType::Variables,
+        callback: Callback<Result<QueryType::ResponseData>>,
+        error_message: &'static str,
+    ) -> Result<FetchTask>
+    where
+        QueryType: GraphQLQuery + 'static,
+    {
+        let request_body = QueryType::build_query(variables);
+        call_server(
+            "/api/graphql",
+            &request_body,
+            callback,
+            move |status: http::StatusCode, data: String| {
+                if status.is_success() {
+                    serde_json::from_str(&data)
+                        .context("Could not parse response")
+                        .and_then(|graphql_client::Response { data, errors }| {
+                            data.ok_or_else(|| anyhow!("Errors: {:?}", errors.unwrap_or(vec![])))
+                        })
+                } else {
+                    Err(anyhow!("{}[{}]: {}", error_message, status, data))
+                }
+            },
+        )
     }
 
     pub fn get_user_details(username: &str, callback: Callback<Result<User>>) -> Result<FetchTask> {

app/src/graphql_api.rs

@@ -0,0 +1,8 @@
+use graphql_client::GraphQLQuery;
+
+#[derive(GraphQLQuery)]
+#[graphql(
+    schema_path = "../schema.graphql",
+    query_path = "queries/list_users.graphql"
+)]
+pub struct ListUsersQuery;

app/src/lib.rs

@@ -4,6 +4,7 @@ mod api;
 mod app;
 mod cookies;
 mod create_user;
+mod graphql_api;
 mod login;
 mod logout;
 mod user_details;

app/src/user_table.rs

@@ -1,4 +1,10 @@
-use crate::api::HostService;
+use crate::{
+    api::HostService,
+    graphql_api::{
+        list_users_query::{self, RequestFilter, ResponseData},
+        ListUsersQuery,
+    },
+};
 use anyhow::{anyhow, Result};
 use lldap_model::*;
 use yew::format::Json;
@@ -13,12 +19,16 @@ pub struct UserTable {
 }
 
 pub enum Msg {
-    ListUsersResponse(Result<Vec<User>>),
+    ListUsersResponse(Result<ResponseData>),
 }
 
 impl UserTable {
-    fn get_users(&mut self, req: ListUsersRequest) {
-        match HostService::list_users(req, self.link.callback(Msg::ListUsersResponse)) {
+    fn get_users(&mut self, req: Option<RequestFilter>) {
+        match HostService::graphql_query::<ListUsersQuery>(
+            list_users_query::Variables { filters: req },
+            self.link.callback(Msg::ListUsersResponse),
+            "",
+        ) {
             Ok(task) => self._task = Some(task),
             Err(e) => {
                 self._task = None;
@@ -38,14 +48,22 @@ impl Component for UserTable {
             _task: None,
             users: None,
         };
-        table.get_users(ListUsersRequest { filters: None });
+        table.get_users(None);
         table
     }
 
     fn update(&mut self, msg: Self::Message) -> ShouldRender {
         match msg {
             Msg::ListUsersResponse(Ok(users)) => {
-                self.users = Some(Ok(users));
+                self.users = Some(Ok(users
+                    .users
+                    .into_iter()
+                    .map(|u| User {
+                        user_id: u.id,
+                        email: u.email,
+                        ..Default::default()
+                    })
+                    .collect()));
                 ConsoleService::log(format!("Response: {:?}", Json(&self.users)).as_str());
                 true
             }