How to best do Views which are not 1:1 Aggregate?

[kelko]

I'm fairly new to DDD and CQRS, still reading through the "blue book". So maybe I choose the wrong approach. But what I want to achieve:

Situation / Goal

I have two ENTITY (both of them are aggregate roots) like

struct Entry {
  title: EntryTitle,
  tags: HashSet<Tag>,
  category_id: CategoryId
}

struct Category {
  title: CategoryTitle
}

EntryTitle, Tag, CategoryTitle and CategoryId are VALUE OBJECTs via simple String wrapping struct. Both ENTITY don't have an id property as those are handled inside cqrs-es if I understand correctly.

Now I want to have 3 views:

• The entries
• The tags (the tags themselves, but also references to entries with that tag)
• The categories (the categories themselves, but also references to entries with that category)

Implemention?

view "entries"

The entries view is 1:1 from the ENTITY Entry, so with cqrs-es I can use the GenericQuery with the Aggregate-implementing Entry. That's simple.

view "tags"

The tags view is derived from the ENTITY Entry and not considered an ENTITY in its own behalf. But rather I want to use that to find/index entries. So a struct implementing the View trait would use the tag itself as "view_id" and have one property: an array of Strings with the IDs of the Entity objects.
That I can't already build up using GenericQuery as it would use aggregate_id as view_id. I made new trait & struct to work around that

pub struct ProjectionQuery<R, V, A>
where
    R: ViewRepository<V, A>,
    V: ProjectionView<A>,
    A: Aggregate,
{
    view_repository: Arc<R>,
    error_handler: Option<Box<QueryErrorHandler>>,
    phantom: PhantomData<(V, A)>,
}

impl<R, V, A> ProjectionQuery<R, V, A>
where
    R: ViewRepository<V, A>,
    V: ProjectionView<A>,
    A: Aggregate,
{
    pub fn new(view_repository: Arc<R>) -> Self {
        Self {
            view_repository,
            error_handler: None,
            phantom: PhantomData,
        }
    }

    pub fn use_error_handler(&mut self, error_handler: Box<QueryErrorHandler>) {
        self.error_handler = Some(error_handler);
    }

    async fn load_mut(&self, view_id: String) -> Result<(V, ViewContext), PersistenceError> {
        Ok(self
            .view_repository
            .load_with_context(&view_id)
            .await?
            .unwrap_or_else(|| (Default::default(), ViewContext::new(view_id, 0))))
    }

    pub(crate) async fn apply_events(
        &self,
        view_id: &str,
        events: &[EventEnvelope<A>],
    ) -> Result<(), PersistenceError> {
        let (mut view, view_context) = self.load_mut(view_id.to_string()).await?;
        for event in events {
            view.update(event);
        }
        self.view_repository.update_view(view, view_context).await?;
        Ok(())
    }

    fn handle_error(&self, error: PersistenceError) {
        if let Some(handler) = &self.error_handler {
            (handler)(error);
        }
    }
}

#[async_trait]
impl<R, V, A> Query<A> for ProjectionQuery<R, V, A>
where
    R: ViewRepository<V, A>,
    V: ProjectionView<A>,
    A: Aggregate,
{
    async fn dispatch(&self, _aggregate_id: &str, events: &[EventEnvelope<A>]) {
        let effected = events
            .iter()
            .flat_map(|e| V::list_effected(e))
            .collect::<Vec<_>>();

        for view_id in effected {
            let events = events
                .iter()
                .filter(|e| V::list_effected(e).contains(&view_id))
                .cloned()
                .collect::<Vec<_>>();
            if let Err(err) = self.apply_events(&view_id, &events).await {
                self.handle_error(err);
            };
        }
    }
}

pub trait ProjectionView<A: Aggregate>: View<A> {
    fn list_effected(event: &EventEnvelope<A>) -> Vec<String>;
}

Generally speaking: It lets me decide which "view_id" is to be used for further processing inside the Query. Rest is taken more or less 1:1 from GenericQuery.

But here I have the problem, that not every event from the ENTITY Entry has all the details. I would need to have access on the Entity struct in that particular version/state to be able to correctly calculate the tags view. (e.g. I have a EntryRemoved event which should cause the view to drop ids referencing now removed Entry entities.)

Question 1: How to build projections/view which are derived from ENTITY, but are not 1:1 linked to an ENTITY?
or, Question 2: Can the EventEnvelope be extended to contain or return (from a method) the then actual, full Aggregate?

view "categories"

The categories in the view are also 1:1 related to the ENTITY Category. So GenericQuery it is. But (!) to be able to have that connection to the entries of that categories I would need to feed this view events from the ENTITY Entry.

Question 3: How to feed events from 2 ENTITY into one view?

Also question 1 above is relevant here, as I would need to also drop references to entries, if the ENTITY Entry is removed.