feat: add VerificationMethod aggregate and related components

Author: nanderstabel

agent_event_publisher_http/src/lib.rs

@@ -4,8 +4,11 @@ use agent_authorization::domain::{
 };
 use agent_holder::presentation::aggregate::Presentation;
 use agent_identity::{
-    connection::aggregate::Connection, document::aggregate::Document, profile::aggregate::Profile,
+    connection::aggregate::Connection,
+    document::aggregate::Document,
+    profile::aggregate::Profile,
     service::aggregate::Service,
+    verification_method::{self, aggregate::VerificationMethod},
 };
 use agent_issuance::{
     credential::aggregate::Credential, offer::aggregate::Offer, server_config::aggregate::ServerConfig,
@@ -17,7 +20,7 @@ use agent_store::{
     ClientEventPublisher, ConnectionEventPublisher, CredentialEventPublisher, DocumentEventPublisher, EventPublisher,
     HolderCredentialEventPublisher, OAuth2AuthorizationRequestEventPublisher, OfferEventPublisher,
     PresentationEventPublisher, ProfileEventPublisher, ReceivedOfferEventPublisher, ServerConfigEventPublisher,
-    ServiceEventPublisher, TemplateEventPublisher,
+    ServiceEventPublisher, TemplateEventPublisher, VerificationMethodEventPublisher,
 };
 use agent_verification::authorization_request::aggregate::AuthorizationRequest;
 use async_trait::async_trait;
@@ -41,6 +44,7 @@ pub struct EventPublisherHttp {
     pub document: Option<AggregateEventPublisherHttp<Document>>,
     pub profile: Option<AggregateEventPublisherHttp<Profile>>,
     pub service: Option<AggregateEventPublisherHttp<Service>>,
+    pub verification_method: Option<AggregateEventPublisherHttp<VerificationMethod>>,
 
     // Library
     pub template: Option<AggregateEventPublisherHttp<Template>>,
@@ -173,6 +177,19 @@ impl EventPublisherHttp {
             )
         });
 
+        let verification_method = (!event_publisher_http.events.verification_method.is_empty()).then(|| {
+            AggregateEventPublisherHttp::<VerificationMethod>::new(
+                event_publisher_http.target_url.clone(),
+                event_publisher_http.headers.clone(),
+                event_publisher_http
+                    .events
+                    .verification_method
+                    .iter()
+                    .map(ToString::to_string)
+                    .collect(),
+            )
+        });
+
         let template = (!event_publisher_http.events.template.is_empty()).then(|| {
             AggregateEventPublisherHttp::<Template>::new(
                 event_publisher_http.target_url.clone(),
@@ -286,6 +303,7 @@ impl EventPublisherHttp {
             document,
             profile,
             service,
+            verification_method,
             template,
             server_config,
             credential,
@@ -327,6 +345,12 @@ impl EventPublisher for EventPublisherHttp {
             .map(|publisher| Box::new(publisher) as ServiceEventPublisher)
     }
 
+    fn verification_method(&mut self) -> Option<VerificationMethodEventPublisher> {
+        self.verification_method
+            .take()
+            .map(|publisher| Box::new(publisher) as VerificationMethodEventPublisher)
+    }
+
     fn template(&mut self) -> Option<TemplateEventPublisher> {
         self.template
             .take()

agent_identity/src/lib.rs

@@ -3,6 +3,7 @@ pub mod connection;
 pub mod document;
 pub mod profile;
 pub mod service;
+pub mod verification_method;
 
 pub mod services;
 pub mod state;

agent_identity/src/state.rs

@@ -8,6 +8,9 @@ use crate::profile::aggregate::{Profile, Source};
 use crate::profile::command::ProfileCommand;
 use crate::profile::views::ProfileView;
 use crate::service::views::all_services::AllServicesView;
+use crate::verification_method::aggregate::VerificationMethod;
+use crate::verification_method::views::all_verification_methods::AllVerificationMethodsView;
+use crate::verification_method::views::VerificationMethodView;
 use crate::{
     document::{aggregate::Document, views::DocumentView},
     service::{aggregate::Service, command::ServiceCommand, views::ServiceView},
@@ -43,6 +46,7 @@ pub struct CommandHandlers {
     pub document: CommandHandler<Document>,
     pub profile: CommandHandler<Profile>,
     pub service: CommandHandler<Service>,
+    pub verification_method: CommandHandler<VerificationMethod>,
 }
 
 /// This type is used to define the queries that are used to query the view repositories. We make use of `dyn` here, so
@@ -56,9 +60,11 @@ type Queries = ViewRepositories<
     dyn ViewRepository<ProfileView, Profile>,
     dyn ViewRepository<ServiceView, Service>,
     dyn ViewRepository<AllServicesView, Service>,
+    dyn ViewRepository<VerificationMethodView, VerificationMethod>,
+    dyn ViewRepository<AllVerificationMethodsView, VerificationMethod>,
 >;
 
-pub struct ViewRepositories<C1, C2, D1, D2, P, S1, S2>
+pub struct ViewRepositories<C1, C2, D1, D2, P, S1, S2, VM1, VM2>
 where
     C1: ViewRepository<ConnectionView, Connection> + ?Sized,
     C2: ViewRepository<AllConnectionsView, Connection> + ?Sized,
@@ -67,6 +73,8 @@ where
     P: ViewRepository<ProfileView, Profile> + ?Sized,
     S1: ViewRepository<ServiceView, Service> + ?Sized,
     S2: ViewRepository<AllServicesView, Service> + ?Sized,
+    VM1: ViewRepository<VerificationMethodView, VerificationMethod> + ?Sized,
+    VM2: ViewRepository<AllVerificationMethodsView, VerificationMethod> + ?Sized,
 {
     pub connection: Arc<C1>,
     pub all_connections: Arc<C2>,
@@ -75,6 +83,8 @@ where
     pub profile: Arc<P>,
     pub service: Arc<S1>,
     pub all_services: Arc<S2>,
+    pub verification_method: Arc<VM1>,
+    pub all_verification_methods: Arc<VM2>,
 }
 
 impl Clone for Queries {
@@ -87,6 +97,8 @@ impl Clone for Queries {
             profile: self.profile.clone(),
             service: self.service.clone(),
             all_services: self.all_services.clone(),
+            verification_method: self.verification_method.clone(),
+            all_verification_methods: self.all_verification_methods.clone(),
         }
     }
 }

agent_identity/src/verification_method/README.md

@@ -0,0 +1,7 @@
+# Service
+
+This aggregate holds everything related to a service:
+- id
+- service (DID Document Service)
+- resource (e.g. Domain Linkage resource)
+

agent_identity/src/verification_method/aggregate.rs

@@ -0,0 +1,80 @@
+use super::{command::VerificationMethodCommand, error::VerificationMethodError, event::VerificationMethodEvent};
+use agent_shared::config::config;
+use async_trait::async_trait;
+use base64::{engine::general_purpose::URL_SAFE_NO_PAD, Engine};
+use cqrs_es::Aggregate;
+use identity_core::{
+    common::{Duration, OrderedSet, Timestamp},
+    convert::{FromJson, ToJson},
+};
+use identity_credential::{
+    credential::Jwt,
+    domain_linkage::{DomainLinkageConfiguration, DomainLinkageCredentialBuilder},
+};
+use identity_did::DIDUrl;
+use jsonwebtoken::{Algorithm, Header};
+use oid4vc_core::Sign as _;
+use serde::{Deserialize, Serialize};
+use serde_json::json;
+use std::{str::FromStr as _, sync::Arc};
+use tracing::{debug, info};
+
+#[derive(Debug, Clone, Serialize, Deserialize, Default)]
+pub struct VerificationMethod {
+    #[serde(rename = "id")]
+    pub verification_method_id: String,
+    pub alias: Option<String>,
+    pub key_id: Option<String>,
+    pub signing_algorithm: Option<String>,
+}
+
+#[async_trait]
+impl Aggregate for VerificationMethod {
+    type Command = VerificationMethodCommand;
+    type Event = VerificationMethodEvent;
+    type Error = VerificationMethodError;
+    type Services = ();
+
+    fn aggregate_type() -> String {
+        "verification_method".to_string()
+    }
+
+    async fn handle(&self, command: Self::Command, services: &Self::Services) -> Result<Vec<Self::Event>, Self::Error> {
+        use VerificationMethodCommand::*;
+        use VerificationMethodError::*;
+        use VerificationMethodEvent::*;
+
+        info!("Handling command: {:?}", command);
+
+        match command {}
+    }
+
+    fn apply(&mut self, event: Self::Event) {
+        use VerificationMethodEvent::*;
+
+        debug!("Applying event: {:?}", event);
+
+        match event {}
+    }
+}
+
+#[cfg(test)]
+pub mod verification_method_tests {
+    use super::test_utils::*;
+    use super::*;
+    use crate::document::aggregate::test_utils::both_verification_methods;
+    use agent_shared::config::set_config;
+    use cqrs_es::test::TestFramework;
+    use identity_iota::verification::VerificationMethod;
+    use rstest::rstest;
+
+    type VerificationMethodTestFramework = TestFramework<VerificationMethod>;
+}
+
+#[cfg(feature = "test_utils")]
+pub mod test_utils {
+    use super::*;
+    use identity_core::{common::Url, convert::FromJson};
+    use rstest::*;
+    use serde_json::json;
+}

agent_identity/src/verification_method/command.rs

@@ -0,0 +1,2 @@
+#[derive(Debug)]
+pub enum VerificationMethodCommand {}

agent_identity/src/verification_method/error.rs

@@ -0,0 +1,4 @@
+use thiserror::Error;
+
+#[derive(Error, Debug)]
+pub enum VerificationMethodError {}

agent_identity/src/verification_method/event.rs

@@ -0,0 +1,18 @@
+use cqrs_es::DomainEvent;
+use derivative::Derivative;
+use serde::{Deserialize, Serialize};
+use strum::Display;
+
+#[derive(Clone, Debug, Deserialize, Serialize, Derivative, Display)]
+#[derivative(PartialEq)]
+pub enum VerificationMethodEvent {}
+
+impl DomainEvent for VerificationMethodEvent {
+    fn event_type(&self) -> String {
+        self.to_string()
+    }
+
+    fn event_version(&self) -> String {
+        "1".to_string()
+    }
+}

agent_identity/src/verification_method/mod.rs

@@ -0,0 +1,5 @@
+pub mod aggregate;
+pub mod command;
+pub mod error;
+pub mod event;
+pub mod views;

agent_identity/src/verification_method/views/all_verification_methods.rs

@@ -0,0 +1,23 @@
+use super::VerificationMethodView;
+use crate::verification_method::aggregate::VerificationMethod;
+use cqrs_es::{EventEnvelope, View};
+use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
+
+#[derive(Debug, Default, Serialize, Deserialize, Clone)]
+pub struct AllVerificationMethodsView {
+    #[serde(flatten)]
+    pub verification_methods: HashMap<String, VerificationMethodView>,
+}
+
+impl View<VerificationMethod> for AllVerificationMethodsView {
+    fn update(&mut self, event: &EventEnvelope<VerificationMethod>) {
+        self.verification_methods
+            // Get the entry for the aggregate_id
+            .entry(event.aggregate_id.clone())
+            // or insert a new one if it doesn't exist
+            .or_default()
+            // update the view with the event
+            .update(event);
+    }
+}