feat(meroctl): support alias listing

crates/meroctl/src/cli/context/identity/alias.rs

@@ -1,9 +1,7 @@
 use calimero_primitives::alias::Alias;
 use calimero_primitives::context::ContextId;
 use calimero_primitives::identity::PublicKey;
-use calimero_server_primitives::admin::{
-    AliasRecord, GetContextIdentitiesResponse, ListAliasesResponse, Report,
-};
+use calimero_server_primitives::admin::{GetContextIdentitiesResponse, ListAliasesResponse};
 use clap::Parser;
 use eyre::{OptionExt, Result as EyreResult, WrapErr};
 use libp2p::identity::Keypair;
@@ -13,7 +11,7 @@ use reqwest::Client;
 use crate::cli::Environment;
 use crate::common::{
     create_alias, delete_alias, do_request, fetch_multiaddr, load_config, lookup_alias,
-    multiaddr_to_url, resolve_alias, RequestType,
+    make_request, multiaddr_to_url, resolve_alias, RequestType,
 };
 use crate::output::ErrorLine;
 
@@ -205,7 +203,8 @@ impl ContextIdentityAliasCommand {
                     .cloned()
                     .ok_or_eyre("Failed to resolve context: no value found")?;
 
-                let ctx_response: ListAliasesResponse<PublicKey> = do_request(
+                make_request::<(), ListAliasesResponse<PublicKey>>(
+                    &environment,
                     &client,
                     multiaddr_to_url(
                         multiaddr,
@@ -216,14 +215,6 @@ impl ContextIdentityAliasCommand {
                     RequestType::Get,
                 )
                 .await?;
-
-                environment.output.write(&ErrorLine(&format!(
-                    "{c1:44} : {c2:44}",
-                    c1 = "Context ID",
-                    c2 = context_id,
-                )));
-
-                environment.output.write(&ErrorLine(&ctx_response.report()));
             }
         }
 

crates/meroctl/src/common.rs

@@ -8,7 +8,8 @@ use calimero_primitives::context::ContextId;
 use calimero_primitives::identity::PublicKey;
 use calimero_server_primitives::admin::{
     AliasKind, CreateAliasRequest, CreateAliasResponse, CreateApplicationIdAlias,
-    CreateContextIdAlias, CreateContextIdentityAlias, DeleteAliasResponse, LookupAliasResponse,
+    CreateContextIdAlias, CreateContextIdentityAlias, DeleteAliasResponse, ListAliasesResponse,
+    LookupAliasResponse,
 };
 use camino::Utf8Path;
 use chrono::Utc;
@@ -429,3 +430,22 @@ where
 
     Ok(ResolveResponse { alias, value })
 }
+
+impl<T: fmt::Display + ScopedAlias + Eq> Report for ListAliasesResponse<T> {
+    fn report(&self) -> () {
+        let mut table = Table::new();
+        let _ = table.set_header(vec![
+            Cell::new("Value").fg(Color::Blue),
+            Cell::new("Alias").fg(Color::Blue),
+        ]);
+
+        for (alias, value) in &self.data {
+            let _ = table.add_row(vec![
+                Cell::new(&value.to_string()),
+                Cell::new(alias.as_str()),
+            ]);
+        }
+
+        table.to_string();
+    }
+}

crates/primitives/src/alias.rs

@@ -3,6 +3,7 @@
 mod tests;
 
 use std::fmt;
+use std::hash::{Hash, Hasher};
 use std::marker::PhantomData;
 use std::str::FromStr;
 
@@ -146,3 +147,9 @@ impl<'de, T> Deserialize<'de> for Alias<T> {
         deserializer.deserialize_str(AliasVisitor(PhantomData))
     }
 }
+
+impl<T> Hash for Alias<T> {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        self.as_str().hash(state);
+    }
+}

crates/server/primitives/src/admin.rs

@@ -1,7 +1,9 @@
+use std::collections::HashMap;
+
 use calimero_context_config::repr::Repr;
 use calimero_context_config::types::{Capability, ContextIdentity, ContextStorageEntry};
 use calimero_context_config::{Proposal, ProposalWithApprovals};
-use calimero_primitives::alias::Alias;
+use calimero_primitives::alias::{Alias, ScopedAlias};
 use calimero_primitives::application::{Application, ApplicationId};
 use calimero_primitives::context::{Context, ContextId, ContextInvitationPayload};
 use calimero_primitives::hash::Hash;
@@ -255,39 +257,19 @@ impl GetContextIdentitiesResponse {
 
 #[derive(Clone, Debug, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
-pub struct AliasRecord<T> {
-    pub alias: Alias<T>,
-    pub value: T,
-}
-
-#[derive(Clone, Debug, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct ListAliasesResponse<T> {
-    pub data: Vec<AliasRecord<T>>,
+pub struct ListAliasesResponse<T>
+where
+    T: ScopedAlias + Eq,
+{
+    pub data: HashMap<Alias<T>, T>,
 }
 
-impl<T> ListAliasesResponse<T> {
-    pub fn new(aliases: Vec<AliasRecord<T>>) -> Self {
-        Self { data: aliases }
-    }
-}
-
-pub trait Report {
-    fn report(&self) -> String;
-}
-
-impl Report for ListAliasesResponse<PublicKey> {
-    fn report(&self) -> String {
-        use std::fmt::Write;
-        let mut output = String::new();
-
-        writeln!(output, "{c1:44} | {c2}", c1 = "Identity", c2 = "Alias").unwrap();
-
-        for AliasRecord { alias, value } in &self.data {
-            writeln!(output, "{c1:44} | {c2}", c1 = value, c2 = alias).unwrap();
-        }
-
-        output
+impl<T> ListAliasesResponse<T>
+where
+    T: ScopedAlias + Eq,
+{
+    pub fn new(data: HashMap<Alias<T>, T>) -> Self {
+        Self { data }
     }
 }
 

crates/server/src/admin/handlers/alias/list_aliases.rs

@@ -1,37 +1,39 @@
+use std::collections::HashMap;
 use std::sync::Arc;
 
 use axum::extract::Path;
 use axum::response::IntoResponse;
 use axum::Extension;
-use calimero_server_primitives::admin::{AliasRecord, ListAliasesResponse};
+use calimero_primitives::alias::Alias;
+use calimero_server_primitives::admin::ListAliasesResponse;
 use calimero_store::key::{Aliasable, StoreScopeCompat};
-use serde::{Deserialize, Serialize};
+use reqwest::StatusCode;
+use serde::Serialize;
 
-use crate::admin::service::{parse_api_error, ApiResponse};
+use crate::admin::service::ApiResponse;
 use crate::AdminState;
 
 pub async fn handler<T>(
     Extension(state): Extension<Arc<AdminState>>,
     maybe_scope: Option<Path<T::Scope>>,
 ) -> impl IntoResponse
 where
-    T: Aliasable + Serialize + Clone + From<[u8; 32]>,
-    T::Scope: Copy + PartialEq + StoreScopeCompat,
+    T: Aliasable<Scope: StoreScopeCompat + Copy + PartialEq> + Serialize + From<[u8; 32]> + Eq,
 {
     let scope = maybe_scope.map(|Path(s)| s);
 
     let aliases_raw = match state.node_client.list_aliases::<T>(scope) {
         Ok(a) => a,
-        Err(err) => return parse_api_error(err).into_response(),
+        Err(err) => return (StatusCode::INTERNAL_SERVER_ERROR, err.to_string()).into_response(),
     };
 
-    let aliases: Vec<AliasRecord<T>> = aliases_raw
+    let data: HashMap<Alias<T>, T> = aliases_raw
         .into_iter()
-        .map(|(alias, value, _scope)| AliasRecord { alias, value })
+        .map(|(alias, value, _scope)| (alias, value))
         .collect();
 
     ApiResponse {
-        payload: ListAliasesResponse::new(aliases),
+        payload: ListAliasesResponse::new(data),
     }
     .into_response()
 }