use euclid::default::Point2D;
use std::collections::BTreeMap;
use uuid::Uuid;
use super::super::import_records::import_records_from_legacy_provenance;
use super::super::*;
use crate::address::{address_from_url, detect_mime};
use crate::persistence::{
GraphSnapshot, PersistedArrangementSubKind, PersistedContainmentSubKind,
PersistedCouplingResponse, PersistedEdge, PersistedFieldExtent, PersistedFieldLifecycle,
PersistedImportedSubKind, PersistedNavigationTrigger, PersistedNodeSelector,
PersistedProvenanceSubKind, PersistedSemanticSubKind,
};
fn semantic_sub_kind(sub_kind: PersistedSemanticSubKind) -> SemanticSubKind {
match sub_kind {
PersistedSemanticSubKind::Hyperlink => SemanticSubKind::Hyperlink,
PersistedSemanticSubKind::UserGrouped => SemanticSubKind::UserGrouped,
PersistedSemanticSubKind::AgentDerived => SemanticSubKind::AgentDerived,
PersistedSemanticSubKind::Cites => SemanticSubKind::Cites,
PersistedSemanticSubKind::Quotes => SemanticSubKind::Quotes,
PersistedSemanticSubKind::Summarizes => SemanticSubKind::Summarizes,
PersistedSemanticSubKind::Elaborates => SemanticSubKind::Elaborates,
PersistedSemanticSubKind::ExampleOf => SemanticSubKind::ExampleOf,
PersistedSemanticSubKind::Supports => SemanticSubKind::Supports,
PersistedSemanticSubKind::Contradicts => SemanticSubKind::Contradicts,
PersistedSemanticSubKind::Questions => SemanticSubKind::Questions,
PersistedSemanticSubKind::SameEntityAs => SemanticSubKind::SameEntityAs,
PersistedSemanticSubKind::DuplicateOf => SemanticSubKind::DuplicateOf,
PersistedSemanticSubKind::CanonicalMirrorOf => SemanticSubKind::CanonicalMirrorOf,
PersistedSemanticSubKind::DependsOn => SemanticSubKind::DependsOn,
PersistedSemanticSubKind::Blocks => SemanticSubKind::Blocks,
PersistedSemanticSubKind::NextStep => SemanticSubKind::NextStep,
}
}
impl Graph {
pub fn from_snapshot(snapshot: &GraphSnapshot) -> Self {
Self::try_from_snapshot(snapshot)
.unwrap_or_else(|error| panic!("invalid graph snapshot: {error}"))
}
pub(super) fn from_snapshot_unchecked(snapshot: &GraphSnapshot) -> Self {
Self::materialize_snapshot(snapshot, true)
}
pub(super) fn from_recorded_snapshot_unchecked(snapshot: &GraphSnapshot) -> Self {
Self::materialize_snapshot(snapshot, false)
}
fn materialize_snapshot(snapshot: &GraphSnapshot, legacy_derived_containment: bool) -> Self {
let mut graph = Graph::new();
graph.nav = snapshot.navigation.clone();
for pnode in &snapshot.nodes {
let Ok(node_id) = Uuid::parse_str(&pnode.node_id) else {
continue;
};
let node_url = {
let from_address = pnode.address.as_url_str();
if from_address.is_empty() {
pnode.url.clone()
} else {
from_address.to_string()
}
};
let (key, inserted) =
graph.insert_node_if_missing(node_id, node_url, Point2D::new(0.0, 0.0));
if !inserted {
continue;
}
if let Some(node) = graph.inner.node_mut(key) {
if node.title != pnode.title {
graph.content_revision = graph.content_revision.wrapping_add(1);
}
node.title = pnode.title.clone();
node.tags = pnode.tags.iter().cloned().collect();
node.images = pnode.images.clone();
node.media_type = pnode.mime_hint.clone();
node.body = pnode.body.clone();
node.nested = pnode.nested.clone().map(muniment::LogId::new);
node.content = pnode
.content_hash
.as_deref()
.and_then(muniment::Hash::from_hex);
if node.content.is_some() {
node.body = None;
}
}
graph.set_node_facet(
key,
super::super::node_facets::PRESENTATION_TAGS,
&pnode.tag_presentation,
);
graph.set_node_facet(
key,
super::super::node_facets::PROVENANCE_IMPORT,
&pnode.import_provenance,
);
graph.set_node_facet(
key,
super::super::node_facets::SEMANTIC_CLASSIFICATIONS,
&pnode.classifications,
);
graph.set_node_facet(
key,
super::super::node_facets::SEMANTIC_PROPERTIES,
&pnode.properties,
);
graph.set_node_facet(
key,
super::super::node_facets::PROVENANCE_DERIVATIONS,
&pnode.derivations,
);
graph.set_node_facet(
key,
super::super::node_facets::ARRANGEMENT_PIN,
&pnode.is_pinned,
);
graph.set_node_facet(
key,
super::super::node_facets::ARRANGEMENT_FRAME_LAYOUT,
&pnode.frame_layout_hints,
);
graph.set_node_facet(
key,
super::super::node_facets::ARRANGEMENT_SPLIT_OFFER_SUPPRESSED,
&pnode.frame_split_offer_suppressed,
);
let last_visited_ms = pnode
.session_state
.as_ref()
.and_then(|session| session.last_visited_ms);
if let Some(last_visited_ms) = last_visited_ms {
graph.set_node_facet(
key,
super::super::node_facets::VISIT_HISTORY,
&super::super::node_facets::VisitHistoryFacet {
last_visited_ms: Some(last_visited_ms),
last_session_visited: pnode.last_session_visited,
},
);
} else if pnode.last_session_visited != 0 {
graph.set_node_last_session_visited(key, pnode.last_session_visited);
}
}
let mut surface_pair_ordinals = BTreeMap::new();
for pedge in &snapshot.edges {
let from_id = Uuid::parse_str(&pedge.from_node_id).ok();
let to_id = Uuid::parse_str(&pedge.to_node_id).ok();
let from_key = from_id.and_then(|id| graph.get_node_key_by_id(id));
let to_key = to_id.and_then(|id| graph.get_node_key_by_id(id));
if let (Some(from), Some(to), Some(from_id), Some(to_id)) =
(from_key, to_key, from_id, to_id)
{
let ordinal = surface_pair_ordinals.entry((from_id, to_id)).or_insert(0);
let pair_ordinal = *ordinal;
*ordinal += 1;
let mut payload =
payload_from_persisted_at(pedge, GraphStratum::Surface, pair_ordinal);
if legacy_derived_containment
&& snapshot.assertion_schema == 0
&& pedge.assertions.is_none()
{
mark_legacy_containment_sidecars_as_derived(&mut payload, pedge);
}
for statement in &mut payload.assertions.statements {
statement.normalize_legacy_asserter();
}
if !payload.is_empty() || pedge.semantic.is_some() || pedge.traversal.is_some() {
graph.inner.connect(from, to, payload);
graph.bump_revision();
}
}
}
for record in &snapshot.resources {
let id = chartulary::resource_id_from_canonical_iri(&record.canonical_iri);
graph.set_resource_record(id, Some(record.clone()));
}
let mut resource_pairs: BTreeMap<(Uuid, Uuid), Vec<PersistedEdge>> = BTreeMap::new();
for edge in &snapshot.resource_edges {
let (Ok(from), Ok(to)) = (
Uuid::parse_str(&edge.from_node_id),
Uuid::parse_str(&edge.to_node_id),
) else {
continue;
};
let mut edge = edge.clone();
if let Some(semantic) = &mut edge.semantic {
for statement in &mut semantic.statements {
statement
.provenance_iri
.get_or_insert_with(|| edge_data::UNKNOWN_LEGACY_ASSERTER_IRI.to_owned());
}
}
resource_pairs.entry((from, to)).or_default().push(edge);
}
for ((from, to), edges) in resource_pairs {
graph.set_resource_edges_between(from, to, &edges);
}
for shown in &snapshot.shown_resources {
if let (Ok(surface), Ok(resource)) = (
Uuid::parse_str(&shown.surface_id),
Uuid::parse_str(&shown.resource_id),
) {
graph.set_shown_resource(surface, Some(resource));
}
}
for pfield in &snapshot.fields {
let Ok(id) = Uuid::parse_str(&pfield.id) else {
continue;
};
let Ok(definition) = serde_json::from_str::<FieldDefinition>(&pfield.definition_json)
else {
continue;
};
let extent = match &pfield.extent {
PersistedFieldExtent::Global => FieldExtent::Global,
PersistedFieldExtent::Region {
min_x,
min_y,
max_x,
max_y,
} => FieldExtent::Region {
min_x: *min_x,
min_y: *min_y,
max_x: *max_x,
max_y: *max_y,
},
PersistedFieldExtent::AttachedToNode(s) => match Uuid::parse_str(s) {
Ok(node_id) => FieldExtent::AttachedToNode(node_id),
Err(_) => FieldExtent::Global,
},
PersistedFieldExtent::Polygon { points } => FieldExtent::Polygon {
points: points.clone(),
},
};
let mut field = Field::new(FieldId::from_uuid(id), definition).with_extent(extent);
if let Some(name) = &pfield.name {
field = field.with_name(name.clone());
}
field.lifecycle = match pfield.lifecycle {
PersistedFieldLifecycle::Active => FieldLifecycle::Active,
PersistedFieldLifecycle::Retired => FieldLifecycle::Retired,
};
graph.add_field(field);
}
for pcoupling in &snapshot.couplings {
let Ok(cid) = Uuid::parse_str(&pcoupling.id) else {
continue;
};
let Ok(fid) = Uuid::parse_str(&pcoupling.field_id) else {
continue;
};
let selector = match &pcoupling.selector {
PersistedNodeSelector::All => NodeSelector::All,
PersistedNodeSelector::Tagged(t) => NodeSelector::Tagged(t.clone()),
PersistedNodeSelector::Kind(k) => NodeSelector::Kind(k.clone()),
PersistedNodeSelector::NotTagged(t) => NodeSelector::NotTagged(t.clone()),
};
let response = match &pcoupling.response {
PersistedCouplingResponse::AttractToMin => CouplingResponse::AttractToMin,
PersistedCouplingResponse::RepelFromMax => CouplingResponse::RepelFromMax,
PersistedCouplingResponse::AlignVelocity => CouplingResponse::AlignVelocity,
PersistedCouplingResponse::FlowAdvect => CouplingResponse::FlowAdvect,
PersistedCouplingResponse::DampenInside { factor } => {
CouplingResponse::DampenInside { factor: *factor }
},
PersistedCouplingResponse::ContainmentWall => CouplingResponse::ContainmentWall,
PersistedCouplingResponse::Open { predicate } => CouplingResponse::Open {
predicate: predicate.clone(),
},
};
graph.add_coupling(Coupling::new(
CouplingId::from_uuid(cid),
FieldId::from_uuid(fid),
selector,
response,
pcoupling.strength,
));
}
graph.import_records = if snapshot.import_records.is_empty() {
import_records_from_legacy_provenance(
snapshot.nodes.iter().filter_map(|pnode| {
let node_id = Uuid::parse_str(&pnode.node_id).ok()?;
Some((node_id, pnode.import_provenance.as_slice()))
}),
snapshot.timestamp_secs,
)
} else {
snapshot.import_records.clone()
};
normalize_import_records(&mut graph.import_records);
graph.sync_node_import_provenance_from_records();
if legacy_derived_containment {
graph.rebuild_derived_containment_relations();
}
graph
}
}
fn mark_legacy_containment_sidecars_as_derived(payload: &mut EdgePayload, edge: &PersistedEdge) {
let Some(containment) = &edge.containment else {
return;
};
let has_derived_sidecar = containment.sub_kinds.iter().any(|kind| {
matches!(
kind,
PersistedContainmentSubKind::UrlPath | PersistedContainmentSubKind::Domain
)
});
if !has_derived_sidecar {
return;
}
for statement in &mut payload.assertions.statements {
if statement.provenance_iri.as_deref() != Some(edge_data::UNKNOWN_LEGACY_ASSERTER_IRI)
|| statement.basis.method.is_some()
|| !matches!(
statement.relation_kind(),
RelationKind::Containment(ContainmentSubKind::UrlPath | ContainmentSubKind::Domain)
)
{
continue;
}
statement.basis.method = Some(crate::types::AssertionMethod {
iri: "urn:mere:method:derived-containment".into(),
version: Some("1".into()),
});
}
payload.assertions.rebuild_compat();
}
impl Graph {
pub(crate) fn restore_persisted_edge(
&mut self,
from: NodeKey,
to: NodeKey,
pedge: &PersistedEdge,
) {
let existing = self.find_edge_key(from, to);
let mut payload = existing
.and_then(|key| self.inner.edge(key))
.cloned()
.unwrap_or_else(EdgePayload::new);
let structural_changes = restore_persisted_payload(&mut payload, pedge);
if pedge.semantic.is_some() || pedge.traversal.is_some() || !payload.is_empty() {
match existing {
Some(key) => *self.inner.edge_mut(key).expect("existing edge") = payload,
None => {
self.inner.connect(from, to, payload);
},
}
}
for _ in 0..structural_changes {
self.bump_revision();
}
}
}
pub(crate) fn payload_from_persisted(pedge: &PersistedEdge) -> EdgePayload {
payload_from_persisted_at(pedge, GraphStratum::Surface, 0)
}
pub(crate) fn payload_from_persisted_at(
pedge: &PersistedEdge,
stratum: GraphStratum,
ordinal: usize,
) -> EdgePayload {
let mut payload = EdgePayload::new();
restore_payload_at(&mut payload, pedge, stratum, ordinal);
payload
}
pub(crate) fn restore_persisted_payload(payload: &mut EdgePayload, pedge: &PersistedEdge) -> usize {
restore_payload_at(payload, pedge, GraphStratum::Surface, 0)
}
fn restore_payload_at(
payload: &mut EdgePayload,
pedge: &PersistedEdge,
stratum: GraphStratum,
ordinal: usize,
) -> usize {
let mut structural_changes = 0;
if let Some(records) = &pedge.assertions {
let mut ids: std::collections::BTreeSet<_> = payload
.assertions()
.iter()
.map(|s| s.statement_id.clone())
.collect();
for record in records {
if ids.insert(record.statement_id.clone()) {
let mut record = runtime_assertion(record);
record.normalize_basis_compat();
payload.assertions.statements.push(record);
structural_changes += 1;
}
}
}
let preserved_ids: std::collections::BTreeSet<_> = payload
.assertions()
.iter()
.map(|s| s.statement_id.clone())
.chain(
pedge
.semantic
.as_ref()
.into_iter()
.flat_map(|data| &data.statements)
.map(|s| s.statement_id.clone()),
)
.collect();
if pedge.assertions.is_none() {
if let Some(semantic) = &pedge.semantic {
if !semantic.statements.is_empty() {
for statement in &semantic.statements {
let _ = payload.push_persisted_semantic_statement(SemanticStatement {
statement_id: statement.statement_id.clone(),
predicate: statement.predicate.clone(),
recognized_sub_kind: statement.recognized_sub_kind.map(semantic_sub_kind),
label: statement.label.clone(),
basis: statement.basis.clone(),
graph_scope: statement.graph_scope.clone(),
provenance_iri: statement.provenance_iri.clone(),
first_asserted_ms: statement.first_asserted_ms,
asserted_at_ms: statement.asserted_at_ms,
withdrawn: statement.withdrawn.clone(),
});
}
} else {
for sub_kind in &semantic.sub_kinds {
payload.assert_semantic_statement(SemanticStatementSpec {
predicate: predicate_iri(semantic_sub_kind(sub_kind.clone())).into(),
recognized_sub_kind: Some(semantic_sub_kind(sub_kind.clone())),
label: semantic.label.clone(),
graph_scope: crate::types::GraphScope::Default,
provenance_iri: Some(edge_data::UNKNOWN_LEGACY_ASSERTER_IRI.into()),
asserted_at_ms: None,
basis: Default::default(),
});
}
if semantic.predicate.is_some() {
payload.set_semantic_predicate(semantic.predicate.clone());
}
}
}
if let Some(arrangement) = &pedge.arrangement {
for sub_kind in &arrangement.sub_kinds {
let assertion = match sub_kind {
PersistedArrangementSubKind::FrameMember => EdgeAssertion::Arrangement {
sub_kind: ArrangementSubKind::FrameMember,
},
PersistedArrangementSubKind::TileGroup => EdgeAssertion::Arrangement {
sub_kind: ArrangementSubKind::TileGroup,
},
PersistedArrangementSubKind::SplitPair => EdgeAssertion::Arrangement {
sub_kind: ArrangementSubKind::SplitPair,
},
PersistedArrangementSubKind::TabNeighbor
| PersistedArrangementSubKind::ActiveTab
| PersistedArrangementSubKind::PinnedInFrame => continue,
};
structural_changes += usize::from(payload.assert_relation(assertion));
}
}
if let Some(containment) = &pedge.containment {
for sub_kind in &containment.sub_kinds {
let sub_kind = match sub_kind {
PersistedContainmentSubKind::UrlPath => ContainmentSubKind::UrlPath,
PersistedContainmentSubKind::Domain => ContainmentSubKind::Domain,
PersistedContainmentSubKind::FileSystem => ContainmentSubKind::FileSystem,
PersistedContainmentSubKind::UserFolder => ContainmentSubKind::UserFolder,
PersistedContainmentSubKind::ClipSource => ContainmentSubKind::ClipSource,
PersistedContainmentSubKind::NotebookSection => {
ContainmentSubKind::NotebookSection
},
PersistedContainmentSubKind::CollectionMember => {
ContainmentSubKind::CollectionMember
},
};
structural_changes +=
usize::from(payload.assert_relation(EdgeAssertion::Containment { sub_kind }));
}
}
if let Some(imported) = &pedge.imported {
for sub_kind in &imported.sub_kinds {
let assertion = match sub_kind {
PersistedImportedSubKind::BookmarkFolder => EdgeAssertion::Imported {
sub_kind: ImportedSubKind::BookmarkFolder,
},
PersistedImportedSubKind::HistoryImport => EdgeAssertion::Imported {
sub_kind: ImportedSubKind::HistoryImport,
},
PersistedImportedSubKind::SessionImport => EdgeAssertion::Imported {
sub_kind: ImportedSubKind::SessionImport,
},
PersistedImportedSubKind::RssMembership => EdgeAssertion::Imported {
sub_kind: ImportedSubKind::RssMembership,
},
PersistedImportedSubKind::FileSystemImport => EdgeAssertion::Imported {
sub_kind: ImportedSubKind::FileSystemImport,
},
PersistedImportedSubKind::ArchiveMembership => EdgeAssertion::Imported {
sub_kind: ImportedSubKind::ArchiveMembership,
},
PersistedImportedSubKind::SharedCollection => EdgeAssertion::Imported {
sub_kind: ImportedSubKind::SharedCollection,
},
};
structural_changes += usize::from(payload.assert_relation(assertion));
}
}
if let Some(provenance) = &pedge.provenance {
for sub_kind in &provenance.sub_kinds {
let assertion = match sub_kind {
PersistedProvenanceSubKind::ClippedFrom => EdgeAssertion::Provenance {
sub_kind: ProvenanceSubKind::ClippedFrom,
},
PersistedProvenanceSubKind::ExcerptedFrom => EdgeAssertion::Provenance {
sub_kind: ProvenanceSubKind::ExcerptedFrom,
},
PersistedProvenanceSubKind::SummarizedFrom => EdgeAssertion::Provenance {
sub_kind: ProvenanceSubKind::SummarizedFrom,
},
PersistedProvenanceSubKind::TranslatedFrom => EdgeAssertion::Provenance {
sub_kind: ProvenanceSubKind::TranslatedFrom,
},
PersistedProvenanceSubKind::RewrittenFrom => EdgeAssertion::Provenance {
sub_kind: ProvenanceSubKind::RewrittenFrom,
},
PersistedProvenanceSubKind::GeneratedFrom => EdgeAssertion::Provenance {
sub_kind: ProvenanceSubKind::GeneratedFrom,
},
PersistedProvenanceSubKind::ExtractedFrom => EdgeAssertion::Provenance {
sub_kind: ProvenanceSubKind::ExtractedFrom,
},
PersistedProvenanceSubKind::ImportedFromSource => EdgeAssertion::Provenance {
sub_kind: ProvenanceSubKind::ImportedFromSource,
},
PersistedProvenanceSubKind::CopiedFrom => EdgeAssertion::Provenance {
sub_kind: ProvenanceSubKind::CopiedFrom,
},
PersistedProvenanceSubKind::MergedFrom => EdgeAssertion::Provenance {
sub_kind: ProvenanceSubKind::MergedFrom,
},
};
structural_changes += usize::from(payload.assert_relation(assertion));
}
}
}
for statement in &mut payload.assertions.statements {
if !preserved_ids.contains(&statement.statement_id) {
statement.statement_id =
legacy_assertion_id(pedge, stratum, ordinal, &statement.predicate);
statement.normalize_legacy_asserter();
}
}
payload.assertions.rebuild_compat();
if let Some(traversal) = &pedge.traversal {
let data = payload.traversal.get_or_insert_with(TraversalData::default);
data.traversals = traversal
.traversals
.iter()
.map(|record| Traversal {
timestamp_ms: record.timestamp_ms,
trigger: match record.trigger {
PersistedNavigationTrigger::Unknown => NavigationTrigger::Unknown,
PersistedNavigationTrigger::LinkClick => NavigationTrigger::LinkClick,
PersistedNavigationTrigger::Back => NavigationTrigger::Back,
PersistedNavigationTrigger::Forward => NavigationTrigger::Forward,
PersistedNavigationTrigger::AddressBarEntry => {
NavigationTrigger::AddressBarEntry
},
PersistedNavigationTrigger::PanePromotion => NavigationTrigger::PanePromotion,
PersistedNavigationTrigger::Programmatic => NavigationTrigger::Programmatic,
PersistedNavigationTrigger::Redirect => NavigationTrigger::Redirect,
PersistedNavigationTrigger::ReopenSession => NavigationTrigger::ReopenSession,
PersistedNavigationTrigger::JumpAnchor => NavigationTrigger::JumpAnchor,
PersistedNavigationTrigger::InPageSearchJump => {
NavigationTrigger::InPageSearchJump
},
PersistedNavigationTrigger::ImportedHistory => {
NavigationTrigger::ImportedHistory
},
},
})
.collect();
data.metrics = EdgeMetrics {
total_navigations: traversal.metrics.total_navigations,
forward_navigations: traversal.metrics.forward_navigations,
backward_navigations: traversal.metrics.backward_navigations,
last_navigated_at: traversal.metrics.last_navigated_at,
};
}
structural_changes
}
fn legacy_assertion_id(
edge: &PersistedEdge,
stratum: GraphStratum,
ordinal: usize,
predicate: &str,
) -> String {
let bytes = serde_json::to_vec(&(
"mere.legacy-relation-assertion",
1u8,
match stratum {
GraphStratum::Surface => "surface",
GraphStratum::Resource => "resource",
},
&edge.from_node_id,
&edge.to_node_id,
ordinal,
predicate,
))
.expect("string tuple JSON");
format!(
"urn:mere:legacy-assertion:v1:{}",
Uuid::new_v5(&Uuid::NAMESPACE_URL, &bytes)
)
}
fn runtime_assertion(
statement: &crate::persistence::PersistedSemanticStatement,
) -> SemanticStatement {
SemanticStatement {
statement_id: statement.statement_id.clone(),
predicate: statement.predicate.clone(),
recognized_sub_kind: statement.recognized_sub_kind.clone().map(semantic_sub_kind),
label: statement.label.clone(),
basis: statement.basis.clone(),
graph_scope: statement.graph_scope.clone(),
provenance_iri: statement.provenance_iri.clone(),
first_asserted_ms: statement.first_asserted_ms,
asserted_at_ms: statement.asserted_at_ms,
withdrawn: statement.withdrawn.clone(),
}
}