Skip to content

armgit / macro

Public Imported from GitHub
0

Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.

5.1 KB
Raw Blame
//! Local calendar range reads and commits.

use super::{Engine, EngineError, WriteResult, effective_records, layer_keys};
use crate::calendar::{
    CalendarCommit, CalendarRangeRequest, CalendarRangeResult, CalendarRangeRow,
    CalendarRangeStorage, OCCURRENCE_TYPENAME, compose_calendar_rows, coverage_gaps,
    project_calendar_range,
};
use crate::revision::Revisioned;
use crate::value::EntityKey;
use std::collections::{BTreeSet, HashMap};

impl<S: CalendarRangeStorage> Engine<S> {
    /// Answers a viewport from cached occurrences.
    ///
    /// Authoritative rows come from the storage range index. Occurrences
    /// touched by an active optimistic layer are projected from their composed
    /// records and replace their authoritative rows, so an optimistic move,
    /// delete, or create is visible before the mutation settles.
    pub async fn calendar_range(
        &mut self,
        request: &CalendarRangeRequest,
    ) -> Result<Revisioned<CalendarRangeResult>, EngineError<S::Error>> {
        request.validate()?;
        self.hydrate_optimistic().await?;
        let snapshot = self
            .storage
            .query_calendar_ranges(request)
            .await
            .map_err(EngineError::Storage)?;
        let overlay = self.optimistic_calendar_overlay().await?;
        let (occurrence_keys, overlaid) = compose_calendar_rows(request, snapshot.rows, &overlay);
        let uncertain_event_keys = self
            .optimistic
            .iter()
            .flat_map(|layer| layer.uncertain_calendar_event_keys.iter().cloned())
            .filter(|key| {
                request
                    .event_key
                    .as_ref()
                    .is_none_or(|event_key| event_key == key)
            })
            .collect::<BTreeSet<_>>()
            .into_iter()
            .collect::<Vec<_>>();
        let gaps = request
            .spans()
            .into_iter()
            .flat_map(|span| coverage_gaps(&snapshot.coverage, span))
            .collect();
        Ok(self.revisioned(CalendarRangeResult {
            occurrence_keys,
            gaps,
            freshness: snapshot.sync.freshness,
            optimistic: overlaid || !uncertain_event_keys.is_empty(),
            uncertain_event_keys,
            watermark: snapshot.sync.watermark,
        }))
    }

    async fn optimistic_calendar_overlay(
        &mut self,
    ) -> Result<HashMap<EntityKey<'static>, Option<CalendarRangeRow>>, EngineError<S::Error>> {
        let keys = layer_keys(&self.optimistic)
            .into_iter()
            .filter(|key| key.typename() == Some(OCCURRENCE_TYPENAME))
            .collect::<BTreeSet<_>>();
        if keys.is_empty() {
            return Ok(HashMap::new());
        }
        let bases = self.load_bases(&keys).await?;
        Ok(effective_records(&bases, &self.optimistic, &keys)
            .into_iter()
            .map(|(key, record)| {
                let row = record.and_then(|record| project_calendar_range(&key, &record));
                (key, row)
            })
            .collect())
    }

    /// Atomically applies coverage, occurrence-set replacements, deletions,
    /// and sync state. Records the commit deletes are evicted and reported as
    /// changed so dependent operations re-execute.
    pub async fn calendar_commit(
        &mut self,
        commit: &CalendarCommit,
    ) -> Result<WriteResult, EngineError<S::Error>> {
        commit.validate()?;
        self.ensure_revision_can_advance()?;
        let outcome = self
            .storage
            .calendar_commit(commit)
            .await
            .map_err(EngineError::Storage)?;
        let changed = outcome.deleted_keys.into_iter().collect::<BTreeSet<_>>();
        for key in &changed {
            self.hot.pop(key);
        }
        let affected_ops = self.deps.ops_for_keys(changed.iter());
        let revision = self.advance_revision()?;
        // Coverage/sync metadata does not change predicate membership. Record
        // every normalized deletion instead of leaving an unknown journal gap.
        self.live_queries.record(
            revision,
            super::live_query::Changes {
                records: changed.clone(),
                projections: changed
                    .iter()
                    .filter_map(|key| predicate_index::RecordKey::new(key.to_string()).ok())
                    .collect(),
            },
        );
        Ok(WriteResult {
            // Deletions carry no values, so invalidation is exact even beneath
            // optimistic layers.
            field_changes: Some(
                changed
                    .iter()
                    .map(|key| crate::field_changes::RecordFieldChange::Invalidate {
                        key: key.clone(),
                    })
                    .collect(),
            ),
            identity_errors: Vec::new(),
            revision,
            revision_advanced: true,
            search_changed_buckets: Some(BTreeSet::new()),
            changed,
            affected_ops,
            reset: false,
            revalidations: Vec::new(),
            mutation_uuid: None,
        })
    }
}