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.

14.3 KB
Raw Blame
//! Native transport glue for the same Soup adapter used by cache-wasm.
//! Application policy stays in soup-filter-cache-adapter; commands hold the
//! engine lock across projection preparation and the atomic cache write.

use super::{Engine, TursoStorage, Variables};
use cache_core::predicate::{PredicateQueryResult, ProjectionMutation};
use predicate_index::{OptimisticProjectionMutation, RecordKey};
use serde::{Deserialize, Serialize};
use serde_json::Value;
use soup_filter_cache_adapter::{
    SoupFilterCompileOutcome, authoritative_projection_mutations,
    compile_current_filter_request as compile_filter_request, dirty_projection_mutations, mail,
    notification_deletion_updates, notification_projection_updates,
    optimistic_notification_updates, optimistic_projection_mutations,
};

/// Same request shape as the browser host's `EntityFilterCacheArgs`.
#[derive(Deserialize)]
#[serde(rename_all = "camelCase", deny_unknown_fields)]
pub struct EntityFilterRequest {
    /// Optional engine-owned row projection and delta cursor.
    pub live_query: Option<soup_filter_cache_adapter::live_query::LiveQueryRequest>,
    /// GraphQL Soup filter AST; policy/validation belongs to the Soup adapter.
    pub filters: Value,
    /// Requested Soup sort method.
    pub sort_method: String,
    /// Requested sort direction.
    pub sort_direction: String,
    /// Bounded maximum page size, validated by the shared compiler.
    pub limit: u16,
    /// Same-query server membership evidence, when reconciliation is requested.
    pub baseline: Option<Vec<PredicateBaselineEntry>>,
    /// Independent local Mail page request, never a server cursor.
    pub mail: Option<mail::PageRequest>,
}

/// Server membership evidence supplied by the caller for this exact query.
#[derive(Deserialize)]
#[serde(rename_all = "camelCase", deny_unknown_fields)]
pub struct PredicateBaselineEntry {
    /// Normalized entity key.
    pub key: String,
    /// RFC 3339 timestamp retaining sub-millisecond sort precision.
    pub sort_timestamp: String,
}

/// Native/browser-compatible filter result. Mail uses the shared adapter's
/// wire representation directly rather than redefining its cursor contract.
#[derive(Serialize)]
#[serde(untagged)]
pub enum EntityFilterResult {
    /// Maintained record deltas for a live query subscription.
    Live(LiveQueryResult),
    /// Canonical cached Mail pagination result.
    Mail(mail::PageResult),
    /// Generic Soup predicate-index result.
    Predicate(PredicateFilterResult),
}

/// Tagged live-view response shared with the browser host.
#[derive(Serialize)]
#[serde(tag = "kind", rename_all = "kebab-case")]
pub enum LiveQueryResult {
    /// Coherent ordered membership and changed selected records.
    LiveQuery {
        /// Core-maintained view delta.
        #[serde(flatten)]
        update: cache_core::engine::live_query::LiveQueryUpdate,
    },
}

/// Generic Soup results matching the browser shell's tagged wire contract.
#[derive(Serialize)]
#[serde(
    tag = "kind",
    rename_all = "kebab-case",
    rename_all_fields = "camelCase"
)]
pub enum PredicateFilterResult {
    /// Local results reconciled with same-query server membership evidence.
    Reconciled {
        /// Effective-view revision.
        revision: String,
        /// Matching normalized entity keys in display order.
        keys: Vec<String>,
        /// Survivors backed only by the supplied server baseline.
        retained_keys: Vec<String>,
        /// Whether queued optimistic work contributed to the result.
        optimistic: bool,
    },
    /// Exact local evaluation over the supported profile.
    Complete {
        /// Effective-view revision.
        revision: String,
        /// Matching normalized entity keys in display order.
        keys: Vec<String>,
        /// Whether queued optimistic work contributed to the result.
        optimistic: bool,
    },
    /// The requested predicate is outside the local support profile.
    Unsupported,
    /// Required cached proof is missing or uncertain, not a negative match.
    Incomplete {
        /// Effective-view revision.
        revision: String,
    },
}

pub(super) async fn filter(
    engine: &mut Engine<TursoStorage>,
    selections: &mut cache_core::record_selection::cache::RecordSelectionCache,
    generation: &str,
    request: EntityFilterRequest,
) -> Result<EntityFilterResult, String> {
    if let Some(live) = &request.live_query {
        if live.release {
            engine.release_live_query(&live.id);
            return Ok(EntityFilterResult::Predicate(
                PredicateFilterResult::Unsupported,
            ));
        }
        if request.mail.is_some() || request.baseline.is_none() {
            return Err(
                "live queries require a reconciled baseline and do not accept mail cursors".into(),
            );
        }
    }
    if let Some(mail_request) = request.mail {
        let baseline = request
            .baseline
            .unwrap_or_default()
            .into_iter()
            .map(|entry| {
                soup_filter_cache_adapter::reconciliation_baseline_entry(
                    entry.key,
                    &entry.sort_timestamp,
                )
            })
            .collect::<Result<Vec<_>, _>>()
            .map_err(|error| error.to_string())?;
        return mail::page_current(
            engine,
            generation,
            request.filters,
            &request.sort_method,
            &request.sort_direction,
            request.limit,
            mail_request,
            &baseline,
        )
        .await
        .map(EntityFilterResult::Mail)
        .map_err(|error| error.to_string());
    }
    let outcome = compile_filter_request(
        request.filters,
        &request.sort_method,
        &request.sort_direction,
        request.limit,
    )
    .map_err(|error| error.to_string())?;
    let result = match outcome {
        SoupFilterCompileOutcome::Unsupported => PredicateFilterResult::Unsupported,
        SoupFilterCompileOutcome::Supported(query) if request.baseline.is_some() => {
            let baseline = request.baseline.unwrap();
            if baseline.len() > cache_core::predicate::reconciliation::MAX_RECONCILIATION_BASELINE {
                return Err("reconciliation baseline is too large".to_owned());
            }
            let baseline = baseline
                .into_iter()
                .map(|entry| {
                    soup_filter_cache_adapter::reconciliation_baseline_entry(
                        entry.key,
                        &entry.sort_timestamp,
                    )
                })
                .collect::<Result<Vec<_>, _>>()
                .map_err(|error| error.to_string())?;
            if let Some(live) = request.live_query {
                let selection = selections
                    .get(engine.schema(), live.document, live.fragment_name)
                    .map_err(|error| error.to_string())?;
                let since = live
                    .since
                    .map(|revision| revision.parse::<cache_core::revision::CacheRevision>())
                    .transpose()
                    .map_err(|error| error.to_string())?;
                let update = engine
                    .read_live_query(
                        &live.id,
                        cache_core::engine::live_query::LiveQuerySpec {
                            query,
                            baseline,
                            selection,
                        },
                        since,
                    )
                    .await
                    .map_err(|error| error.to_string())?;
                return Ok(EntityFilterResult::Live(LiveQueryResult::LiveQuery {
                    update,
                }));
            }
            let result = engine
                .reconcile_predicate_index(&query, &baseline)
                .await
                .map_err(|error| error.to_string())?;
            PredicateFilterResult::Reconciled {
                revision: result.revision.to_string(),
                keys: result
                    .value
                    .keys
                    .into_iter()
                    .map(|key| key.as_str().to_owned())
                    .collect(),
                retained_keys: result
                    .value
                    .retained_keys
                    .into_iter()
                    .map(|key| key.as_str().to_owned())
                    .collect(),
                optimistic: result.value.optimistic,
            }
        }
        SoupFilterCompileOutcome::Supported(query) => {
            let result = engine
                .query_predicate_index(&query)
                .await
                .map_err(|error| error.to_string())?;
            let revision = result.revision.to_string();
            match result.value {
                PredicateQueryResult::Complete(keys) => PredicateFilterResult::Complete {
                    revision,
                    keys: keys
                        .into_iter()
                        .map(|key| key.as_str().to_owned())
                        .collect(),
                    optimistic: false,
                },
                PredicateQueryResult::Optimistic(keys) => PredicateFilterResult::Complete {
                    revision,
                    keys: keys
                        .into_iter()
                        .map(|key| key.as_str().to_owned())
                        .collect(),
                    optimistic: true,
                },
                PredicateQueryResult::Incomplete => PredicateFilterResult::Incomplete { revision },
            }
        }
    };
    Ok(EntityFilterResult::Predicate(result))
}

pub(super) async fn write_projections(
    engine: &mut Engine<TursoStorage>,
    query: &str,
    operation: Option<&str>,
    variables: &Variables,
    data: &Value,
    identity: Option<&str>,
) -> Result<Vec<ProjectionMutation>, String> {
    let mut projections =
        authoritative_projection_mutations(engine.schema(), query, operation, data)
            .map_err(|error| error.to_string())?;
    // Do not compose the new viewer's partial writes with the old viewer's
    // authoritative data. Engine still owns the actual atomic identity reset.
    let reuse_stored_identity = match identity {
        Some(observed) => engine
            .current_identity()
            .await
            .map_err(|error| error.to_string())?
            .as_deref()
            .is_none_or(|bound| bound == observed),
        None => true,
    };
    if reuse_stored_identity {
        projections.extend(
            notification_projection_updates(
                engine.schema(),
                engine.storage(),
                query,
                operation,
                variables,
                data,
            )
            .await
            .map_err(|error| error.to_string())?,
        );
    }
    projections.extend(
        mail::projection_updates_for_write(
            engine.schema(),
            engine.storage(),
            query,
            operation,
            variables,
            data,
            reuse_stored_identity,
        )
        .await
        .map_err(|error| error.to_string())?,
    );
    soup_filter_cache_adapter::properties::augment_authoritative(
        engine.schema(),
        engine.storage(),
        query,
        operation,
        variables,
        data,
        reuse_stored_identity,
        projections,
    )
    .await
    .map_err(|error| error.to_string())
}

pub(super) async fn optimistic_projections(
    engine: &Engine<TursoStorage>,
    query: &str,
    operation: Option<&str>,
    variables: &Variables,
    data: &Value,
    created_at_ms: i64,
) -> Result<Vec<OptimisticProjectionMutation>, String> {
    let mut projections = optimistic_projection_mutations(data, created_at_ms);
    projections.extend(
        optimistic_notification_updates(
            notification_projection_updates(
                engine.schema(),
                engine.storage(),
                query,
                operation,
                variables,
                data,
            )
            .await
            .map_err(|error| error.to_string())?,
        )
        .map_err(|error| error.to_string())?,
    );
    projections.extend(mail::optimistic_updates(
        mail::projection_updates(
            engine.schema(),
            engine.storage(),
            query,
            operation,
            variables,
            data,
        )
        .await
        .map_err(|error| error.to_string())?,
    ));
    projections.extend(
        mail::draft_optimistic_updates(
            engine.schema(),
            engine.storage(),
            query,
            operation,
            variables,
            data,
        )
        .await
        .map_err(|error| error.to_string())?,
    );
    soup_filter_cache_adapter::properties::augment_optimistic(
        engine.schema(),
        engine.storage(),
        query,
        operation,
        variables,
        data,
        projections,
    )
    .await
    .map_err(|error| error.to_string())
}

pub(super) async fn invalidation_projections(
    engine: &Engine<TursoStorage>,
    keys: &[String],
) -> Result<Vec<ProjectionMutation>, String> {
    let mut projections = dirty_projection_mutations(keys);
    projections.extend(mail::dirty_updates(keys));
    projections.extend(
        notification_deletion_updates(engine.storage(), keys, true)
            .await
            .map_err(|error| error.to_string())?,
    );
    projections.extend(
        soup_filter_cache_adapter::properties::deletion_updates(engine.storage(), keys)
            .await
            .map_err(|error| error.to_string())?,
    );
    Ok(soup_filter_cache_adapter::properties::current_mutations(
        projections,
    ))
}

pub(super) async fn deletion_projections(
    engine: &Engine<TursoStorage>,
    keys: &[String],
) -> Result<Vec<ProjectionMutation>, String> {
    let mut projections = notification_deletion_updates(engine.storage(), keys, false)
        .await
        .map_err(|error| error.to_string())?;
    projections.extend(
        keys.iter()
            .filter_map(|key| RecordKey::new(key.clone()).ok())
            .map(ProjectionMutation::Delete),
    );
    projections.extend(
        soup_filter_cache_adapter::properties::deletion_updates(engine.storage(), keys)
            .await
            .map_err(|error| error.to_string())?,
    );
    Ok(soup_filter_cache_adapter::properties::current_mutations(
        projections,
    ))
}