feat(meroctl): support alias listing

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

@@ -1,7 +1,9 @@
 use calimero_primitives::alias::Alias;
 use calimero_primitives::context::ContextId;
 use calimero_primitives::identity::PublicKey;
-use calimero_server_primitives::admin::GetContextIdentitiesResponse;
+use calimero_server_primitives::admin::{
+    AliasRecord, GetContextIdentitiesResponse, ListAliasesResponse, Report,
+};
 use clap::Parser;
 use eyre::{OptionExt, Result as EyreResult, WrapErr};
 use libp2p::identity::Keypair;
@@ -10,8 +12,8 @@ use reqwest::Client;
 
 use crate::cli::Environment;
 use crate::common::{
-    create_alias, delete_alias, fetch_multiaddr, load_config, lookup_alias, multiaddr_to_url,
-    resolve_alias,
+    create_alias, delete_alias, do_request, fetch_multiaddr, load_config, lookup_alias,
+    multiaddr_to_url, resolve_alias, RequestType,
 };
 use crate::output::ErrorLine;
 
@@ -87,6 +89,13 @@ pub enum ContextIdentityAliasSubcommand {
         #[arg(long, short, default_value = "default")]
         context: Alias<ContextId>,
     },
+
+    #[command(about = "List all the aliases under the context", alias = "ls")]
+    List {
+        #[arg(help = "The context whose aliases need to be listed")]
+        #[arg(long, short, default_value = "default")]
+        context: Alias<ContextId>,
+    },
 }
 
 impl ContextIdentityAliasCommand {
@@ -185,6 +194,37 @@ impl ContextIdentityAliasCommand {
 
                 environment.output.write(&res);
             }
+
+            ContextIdentityAliasSubcommand::List { context } => {
+                let client = Client::new();
+
+                let resolve_response =
+                    resolve_alias(multiaddr, &config.identity, context, None).await?;
+                let context_id = resolve_response
+                    .value()
+                    .cloned()
+                    .ok_or_eyre("Failed to resolve context: no value found")?;
+
+                let ctx_response: ListAliasesResponse<PublicKey> = do_request(
+                    &client,
+                    multiaddr_to_url(
+                        multiaddr,
+                        &format!("/admin-api/dev/aliases/identity/{context_id}"),
+                    )?,
+                    None::<()>,
+                    &config.identity,
+                    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()));
+            }
         }
 
         Ok(())

crates/node/src/interactive_cli/context/identity.rs

@@ -131,7 +131,8 @@ enum ContextIdentityAliasSubcommands {
     #[command(about = "List context identity aliases", alias = "ls")]
     List {
         /// The context whose aliases we're listing
-        context: Option<Alias<ContextId>>,
+        #[arg(long, short, default_value = "default")]
+        context: Alias<ContextId>,
     },
 }
 
@@ -415,17 +416,10 @@ fn handle_alias_command(
                 c2 = "Identity",
                 c3 = "Alias",
             );
-            let context_id = if let Some(ctx) = context {
-                node_client
-                    .resolve_alias(ctx, None)?
-                    .ok_or_eyre("unable to resolve context alias")?
-            } else {
-                let default_alias: Alias<ContextId> =
-                    "default".parse().expect("'default' is a valid alias name");
-                node_client
-                    .lookup_alias(default_alias, None)?
-                    .ok_or_eyre("unable to resolve default context")?
-            };
+            let context_id = node_client
+                .resolve_alias(context, None)?
+                .ok_or_eyre("unable to resolve context alias")?;
+
             for (alias, identity, scope) in
                 node_client.list_aliases::<PublicKey>(Some(context_id))?
             {

crates/server/primitives/src/admin.rs

@@ -253,6 +253,44 @@ 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>>,
+}
+
+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
+    }
+}
+
 #[derive(Clone, Debug, Deserialize, Serialize)]
 #[serde(rename_all = "camelCase")]
 pub struct GetContextClientKeysResponseData {

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

@@ -1,10 +1,11 @@
-use axum::routing::{post, Router};
+use axum::routing::{get, post, Router};
 use calimero_primitives::application::ApplicationId;
 use calimero_primitives::context::ContextId;
 use calimero_primitives::identity::PublicKey;
 
 mod create_alias;
 mod delete_alias;
+mod list_aliases;
 mod lookup_alias;
 
 pub fn service() -> Router {
@@ -38,8 +39,17 @@ pub fn service() -> Router {
             post(delete_alias::handler::<PublicKey>),
         );
 
+    let list_routes = Router::new()
+        .route("/context", get(list_aliases::handler::<ContextId>))
+        .route("/application", get(list_aliases::handler::<ApplicationId>))
+        .route(
+            "/identity/:context",
+            get(list_aliases::handler::<PublicKey>),
+        );
+
     Router::new()
         .nest("/create", create_routes)
         .nest("/lookup", lookup_routes)
         .nest("/delete", delete_routes)
+        .nest("/list", list_routes)
 }

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

@@ -0,0 +1,37 @@
+use std::sync::Arc;
+
+use axum::extract::Path;
+use axum::response::IntoResponse;
+use axum::Extension;
+use calimero_server_primitives::admin::{AliasRecord, ListAliasesResponse};
+use calimero_store::key::{Aliasable, StoreScopeCompat};
+use serde::{Deserialize, Serialize};
+
+use crate::admin::service::{parse_api_error, 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,
+{
+    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(),
+    };
+
+    let aliases: Vec<AliasRecord<T>> = aliases_raw
+        .into_iter()
+        .map(|(alias, value, _scope)| AliasRecord { alias, value })
+        .collect();
+
+    ApiResponse {
+        payload: ListAliasesResponse::new(aliases),
+    }
+    .into_response()
+}