1mod copies;
18
19use std::collections::{BTreeMap, BTreeSet};
20use std::fmt;
21
22pub use super::legacy_content_migration::LegacyContentContext;
23
24use serde::{Deserialize, Serialize};
25use uuid::Uuid;
26
27use super::capture::{
28 OnRefusal, Replay as Outcome, ReplayAttribution, replay_attributed_deltas_onto,
29 replay_graph_deltas_onto,
30};
31use super::predicate_declarations::PREDICATE_DECLARATIONS_FACET;
32use super::snapshot::{payload_from_persisted, persisted_edge_for_ids};
33use super::{AttributedDelta, CapturedDelta, EdgePayload, Graph, GraphStratum, ResourceNode};
34use crate::persistence::{
35 GraphSnapshot, PersistedContainmentEdgeData, PersistedEdge, PersistedImportedEdgeData,
36 PersistedProvenanceEdgeData, PersistedResourceFacet, PersistedResourceRecord,
37 PersistedSemanticStatement,
38};
39
40pub const LEGACY_RESOURCE_MIGRATION_FACET: &str = "semantic.legacy-resource-migration/v1";
42pub const LEGACY_AGGREGATE_MIGRATION_FACET: &str = "semantic.legacy-aggregate-migration/v1";
43
44#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
46pub struct LegacyAggregateMigrationNote {
47 pub from_surface_id: String,
48 pub to_surface_id: String,
49 pub from_resource_id: String,
50 pub to_resource_id: String,
51 pub from_url: String,
52 pub to_url: String,
53 pub kind: super::RelationKind,
54 pub author: Option<super::Author>,
55 pub uncertainty: String,
56}
57
58#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
60pub struct LegacyResourceOriginResolution {
61 pub statement_id: String,
62 pub from_resource_id: Uuid,
63 pub to_resource_id: Uuid,
64}
65
66pub fn validate_legacy_origin_resolutions(
68 baseline: &Graph,
69 entries: &[AttributedDelta],
70 resolutions: &[LegacyResourceOriginResolution],
71) -> Result<(), LegacyMigrationError> {
72 validated_resolutions(&probe_legacy_mint_links(baseline, entries)?, resolutions).map(|_| ())
73}
74
75fn validated_resolutions(
76 diagnostics: &[LegacyMintLinkDiagnostic],
77 resolutions: &[LegacyResourceOriginResolution],
78) -> Result<BTreeMap<String, Pair>, LegacyMigrationError> {
79 let mut candidates = BTreeMap::<String, BTreeSet<Pair>>::new();
80 for diagnostic in diagnostics {
81 let pairs = candidates
82 .entry(diagnostic.statement_id.clone())
83 .or_default();
84 for pair in [
85 &diagnostic.earlier_resource_pair,
86 &diagnostic.current_resource_pair,
87 ] {
88 pairs.insert((parse_id(&pair.0)?, parse_id(&pair.1)?));
89 }
90 }
91 let mut selected = BTreeMap::new();
92 for resolution in resolutions {
93 let pair = (resolution.from_resource_id, resolution.to_resource_id);
94 if !candidates
95 .get(&resolution.statement_id)
96 .is_some_and(|pairs| pairs.contains(&pair))
97 {
98 return Err(LegacyMigrationError(format!(
99 "checkpoint C28: invalid resource origin for {}",
100 resolution.statement_id
101 )));
102 }
103 if let Some(previous) = selected.insert(resolution.statement_id.clone(), pair)
104 && previous != pair
105 {
106 return Err(LegacyMigrationError(format!(
107 "checkpoint C28: conflicting resource origins for {}",
108 resolution.statement_id
109 )));
110 }
111 }
112 if candidates.keys().any(|id| !selected.contains_key(id)) {
113 return Err(LegacyMigrationError(format!(
114 "checkpoint C28: {} unresolved legacy mint-link handles",
115 candidates
116 .keys()
117 .filter(|id| !selected.contains_key(*id))
118 .count()
119 )));
120 }
121 Ok(selected)
122}
123
124#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
125pub struct LegacyMigrationNote {
126 pub from_surface_id: String,
127 pub to_surface_id: String,
128 pub from_resource_id: String,
129 pub to_resource_id: String,
130 pub from_url: String,
131 pub to_url: String,
132 pub statement: PersistedSemanticStatement,
133 pub uncertainty: String,
134}
135
136#[derive(Debug, Clone, PartialEq, Eq)]
137pub struct LegacyMigrationError(pub String);
138
139impl fmt::Display for LegacyMigrationError {
140 fn fmt(&self, out: &mut fmt::Formatter<'_>) -> fmt::Result {
141 out.write_str(&self.0)
142 }
143}
144impl std::error::Error for LegacyMigrationError {}
145
146pub struct MigratedReplay {
148 pub graph: Graph,
149 pub baseline_effects: Vec<CapturedDelta>,
150 pub entry_effects: Vec<Vec<CapturedDelta>>,
151}
152
153#[derive(Debug, Clone, PartialEq, Eq)]
155pub struct LegacyMintLinkDiagnostic {
156 pub raw_entry_index: usize,
157 pub carried_entry_index: usize,
158 pub statement_id: String,
159 pub surface_pair: (String, String),
160 pub earlier_resource_pair: (String, String),
161 pub current_resource_pair: (String, String),
162 pub explicit_source_matches: bool,
163}
164
165pub fn probe_legacy_mint_links(
168 baseline: &Graph,
169 entries: &[AttributedDelta],
170) -> Result<Vec<LegacyMintLinkDiagnostic>, LegacyMigrationError> {
171 let mut source = baseline.clone();
172 source.stage_edges();
173 let mut attribution = ReplayAttribution::from_baseline(baseline);
174 let mut known = statement_ids(&baseline.to_snapshot().edges);
175 let mut raw = Vec::<(usize, Pair, super::SemanticStatement, Pair)>::new();
176 let mut diagnostics = Vec::new();
177 for (index, entry) in entries.iter().enumerate() {
178 let before = surface_pairs(&source)?;
179 let _ =
180 replay_attributed_deltas_onto(&mut source, &mut attribution, [entry], OnRefusal::Drop);
181 let after = surface_pairs(&source)?;
182 for (&pair, edges) in &after {
183 let old = statement_ids(before.get(&pair).map(Vec::as_slice).unwrap_or(&[]));
184 let endpoints = current_resource_pair(&source, pair)?;
185 for edge in edges {
186 let payload = payload_from_persisted(edge);
187 for statement in payload.semantic_statements() {
188 if old.contains(&statement.statement_id) {
189 continue;
190 }
191 let identity = statement.clone();
192 if matches!(entry.delta, CapturedDelta::ReplaySetEdgesByIds { .. })
193 && !known.contains(&statement.statement_id)
194 && statement.recognized_sub_kind.is_none()
195 && super::built_in_predicate_stratum(&statement.predicate).is_none()
196 {
197 source.effective_predicate_stratum(&statement.predicate).map_err(|error|
198 LegacyMigrationError(format!("checkpoint C22: new carried handle {} has unresolved placement: {error}", statement.statement_id)))?;
199 }
200 let resource_placed =
201 historical_statement_stratum(&source, statement) == GraphStratum::Resource;
202 if raw_semantic_edit(&entry.delta) && resource_placed {
203 raw.push((index, pair, identity, endpoints));
204 } else if let CapturedDelta::ReplaySetEdgesByIds { edges, .. } = &entry.delta
205 && !known.contains(&statement.statement_id)
206 && resource_placed
207 {
208 let explicit = edges
209 .iter()
210 .flat_map(|edge| edge.retained_assertions())
211 .find(|carried| carried.statement_id == statement.statement_id)
212 .and_then(|carried| carried.provenance_iri.as_ref())
213 .filter(|source| {
214 source.as_str() != super::edge_data::UNKNOWN_LEGACY_ASSERTER_IRI
215 });
216 for (raw_index, raw_pair, earlier, earlier_endpoints) in &raw {
217 if *raw_pair == pair
218 && *earlier_endpoints != endpoints
219 && earlier.predicate == identity.predicate
220 && earlier.recognized_sub_kind == identity.recognized_sub_kind
221 && earlier.graph_scope == identity.graph_scope
222 && (explicit.is_none()
223 || earlier.provenance_iri == identity.provenance_iri)
224 {
225 diagnostics.push(LegacyMintLinkDiagnostic {
226 raw_entry_index: *raw_index,
227 carried_entry_index: index,
228 statement_id: statement.statement_id.clone(),
229 surface_pair: (pair.0.to_string(), pair.1.to_string()),
230 earlier_resource_pair: (
231 earlier_endpoints.0.to_string(),
232 earlier_endpoints.1.to_string(),
233 ),
234 current_resource_pair: (
235 endpoints.0.to_string(),
236 endpoints.1.to_string(),
237 ),
238 explicit_source_matches: explicit.is_some()
239 && earlier.provenance_iri == identity.provenance_iri,
240 });
241 }
242 }
243 }
244 known.insert(statement.statement_id.clone());
245 }
246 }
247 }
248 }
249 Ok(diagnostics)
250}
251
252type Pair = (Uuid, Uuid);
253type Pairs = BTreeMap<Pair, Vec<PersistedEdge>>;
254
255#[derive(Clone)]
256struct Origin {
257 surface: Pair,
258 resource: Option<Pair>,
259 claim: super::SemanticStatement,
261}
262
263#[derive(Clone, PartialEq)]
264struct Membership {
265 surface: Pair,
266 resource: Pair,
267 edges: Vec<PersistedEdge>,
268}
269
270struct Replay {
271 source: Graph,
272 output: Graph,
273 attribution: ReplayAttribution,
274 origins: BTreeMap<String, Origin>,
275 active: BTreeMap<String, Membership>,
276 aggregate_origins: BTreeMap<(Pair, u32), Pair>,
277 aggregate_active: BTreeMap<(Pair, u32), Membership>,
278 resolutions: BTreeMap<String, Pair>,
279 authored_declarations: BTreeSet<String>,
280 content: super::legacy_content_migration::ContentReplay,
281 content_context: Option<super::legacy_content_migration::LegacyContentContext>,
282}
283
284pub fn migrate_legacy_prefix(
290 baseline: &Graph,
291 entries: &[AttributedDelta],
292) -> Result<MigratedReplay, LegacyMigrationError> {
293 migrate_legacy_prefix_with_resolutions(baseline, entries, &[])
294}
295
296pub fn migrate_legacy_prefix_with_resolutions(
298 baseline: &Graph,
299 entries: &[AttributedDelta],
300 resolutions: &[LegacyResourceOriginResolution],
301) -> Result<MigratedReplay, LegacyMigrationError> {
302 migrate_legacy_prefix_with_content_context(baseline, entries, resolutions, None)
303}
304
305pub fn migrate_legacy_prefix_with_content_context(
307 baseline: &Graph,
308 entries: &[AttributedDelta],
309 resolutions: &[LegacyResourceOriginResolution],
310 context: Option<&super::legacy_content_migration::LegacyContentContext>,
311) -> Result<MigratedReplay, LegacyMigrationError> {
312 if let Some(context) = context {
313 let iri = url::Url::parse(&context.original_mere_iri).map_err(|_| {
314 LegacyMigrationError("original-mere content namespace must be an absolute IRI".into())
315 })?;
316 if iri.scheme().is_empty()
317 || context
318 .original_mere_iri
319 .chars()
320 .any(|c| c.is_whitespace() || c.is_control())
321 {
322 return Err(LegacyMigrationError(
323 "invalid original-mere content namespace".into(),
324 ));
325 }
326 }
327 let diagnostics = probe_legacy_mint_links(baseline, entries)?;
328 let resolutions = validated_resolutions(&diagnostics, resolutions)?;
329 let mut replay = Replay {
330 source: baseline.clone(),
331 output: baseline.clone(),
332 attribution: ReplayAttribution::from_baseline(baseline),
333 origins: BTreeMap::new(),
334 active: BTreeMap::new(),
335 aggregate_origins: BTreeMap::new(),
336 aggregate_active: BTreeMap::new(),
337 resolutions,
338 content: Default::default(),
339 content_context: context.cloned(),
340 authored_declarations: baseline
341 .to_snapshot()
342 .resources
343 .into_iter()
344 .filter(|record| {
345 record
346 .facets
347 .iter()
348 .any(|facet| facet.facet == PREDICATE_DECLARATIONS_FACET)
349 })
350 .map(|record| record.canonical_iri)
351 .collect(),
352 };
353 replay.source.stage_edges();
354 replay.output.stage_edges();
355 let before = replay.output.to_snapshot();
356 let before_facets = replay.output.facets().clone();
357 replay.sync(&Pairs::new(), true, None)?;
358 replay.content.sync(
359 &replay.source,
360 &mut replay.output,
361 replay.content_context.as_ref(),
362 None,
363 )?;
364 let mut baseline_effects = facet_effects_between(&before_facets, replay.output.facets());
365 baseline_effects.extend(effects_between(
366 &before,
367 &replay.output.to_snapshot(),
368 replay.output.facets(),
369 )?);
370 let mut entry_effects = Vec::with_capacity(entries.len());
371 for (index, entry) in entries.iter().enumerate() {
372 let before = replay.output.to_snapshot();
373 let before_facets = replay.output.facets().clone();
374 let old_pairs = surface_pairs(&replay.source)?;
375 let typed_pair = typed_resource_pair(&entry.delta)?;
376 replay.content.typed_record(&entry.delta);
377 if let Some(pair) = typed_pair {
378 replay.active.retain(|_, member| member.resource != pair);
380 replay
381 .aggregate_active
382 .retain(|_, member| member.resource != pair);
383 let Outcome::Apply(delta) = replay.attribution.replay(&entry.delta, &entry.author)
384 else {
385 return Err(LegacyMigrationError(
386 "invalid typed resource capture".into(),
387 ));
388 };
389 let super::apply::GraphDelta::ReplaySetResourceEdgesByIds { edges, .. } = &delta else {
390 unreachable!()
391 };
392 let expected = edges.clone();
393 let _ = replay_graph_deltas_onto(&mut replay.output, [delta], OnRefusal::Drop);
394 let actual = replay
395 .output
396 .persisted_resource_edges_between(pair.0, pair.1);
397 if actual != expected {
398 return Err(LegacyMigrationError(
399 "typed resource pair replacement was refused".into(),
400 ));
401 }
402 } else {
403 let _ = replay_attributed_deltas_onto(
404 &mut replay.source,
405 &mut replay.attribution,
406 [entry],
407 OnRefusal::Drop,
408 );
409 if !legacy_edge_edit(&entry.delta) {
410 match entry.delta.replay_as(&entry.author) {
411 Outcome::Apply(delta) => {
412 let _ =
413 replay_graph_deltas_onto(&mut replay.output, [delta], OnRefusal::Drop);
414 },
415 Outcome::Skip => {},
416 Outcome::Malformed(bad) => {
417 return Err(LegacyMigrationError(format!(
418 "legacy journal entry {index}: {bad}"
419 )));
420 },
421 }
422 replay.check_typed_record(&entry.delta)?;
423 }
424 }
425 if let CapturedDelta::ReplaySetResourceRecordById {
426 record: Some(record),
427 ..
428 } = &entry.delta
429 && record
430 .facets
431 .iter()
432 .any(|facet| facet.facet == PREDICATE_DECLARATIONS_FACET)
433 {
434 replay
435 .authored_declarations
436 .insert(record.canonical_iri.clone());
437 }
438 let after_original = replay.output.to_snapshot();
439 let after_original_facets = replay.output.facets().clone();
440 replay.sync(&old_pairs, false, Some(entry))?;
441 replay.content.sync(
442 &replay.source,
443 &mut replay.output,
444 replay.content_context.as_ref(),
445 Some(&entry.author),
446 )?;
447 if let Some(surface) = lifecycle_surface(&entry.delta)?
448 && replay.source.get_node_key_by_id(surface).is_some()
449 {
450 let (resource, _) = replay.ensure_resource(surface)?;
451 replay.output.set_shown_resource(surface, Some(resource));
452 }
453 let mut effective = Vec::new();
454 if !legacy_edge_edit(&entry.delta) {
455 effective.push(entry.delta.clone());
456 }
457 effective.extend(facet_effects_between(
458 &before_facets,
459 replay.output.facets(),
460 ));
461 effective.extend(effects_between(
462 &before,
463 &replay.output.to_snapshot(),
464 replay.output.facets(),
465 )?);
466 let mut corrections = facet_effects_between(&after_original_facets, replay.output.facets());
469 corrections.extend(effects_between(
470 &after_original,
471 &replay.output.to_snapshot(),
472 replay.output.facets(),
473 )?);
474 effective.extend(corrections);
475 entry_effects.push(effective);
476 }
477 replay
478 .output
479 .settle_staged_edges()
480 .map_err(|error| LegacyMigrationError(error.to_string()))?;
481 Graph::try_from_snapshot(&replay.output.to_snapshot())
483 .map_err(|error| LegacyMigrationError(error.to_string()))?;
484 Ok(MigratedReplay {
485 graph: replay.output,
486 baseline_effects,
487 entry_effects,
488 })
489}
490
491impl Replay {
492 fn check_typed_record(&self, delta: &CapturedDelta) -> Result<(), LegacyMigrationError> {
493 match delta {
494 CapturedDelta::ReplaySetResourceRecordById {
495 resource_id,
496 record,
497 } => {
498 let id = parse_id(resource_id)?;
499 let actual = self.output.resource_record(id);
500 let actual = actual.as_ref().map(record_value).transpose()?;
501 let expected = record.as_ref().map(record_value).transpose()?;
502 if actual != expected {
503 return Err(LegacyMigrationError(
504 "typed resource record replacement was refused".into(),
505 ));
506 }
507 },
508 CapturedDelta::ReplaySetShownResourceById {
509 surface_id,
510 resource_id,
511 } => {
512 let surface = self
513 .output
514 .get_node_key_by_id(parse_id(surface_id)?)
515 .ok_or_else(|| {
516 LegacyMigrationError("typed shown binding has no surface".into())
517 })?;
518 let expected = resource_id.as_deref().map(parse_id).transpose()?;
519 if self.output.shown_resource_id(surface) != expected {
520 return Err(LegacyMigrationError(
521 "typed shown binding was refused".into(),
522 ));
523 }
524 },
525 _ => {},
526 }
527 Ok(())
528 }
529
530 fn ensure_resource(&mut self, surface: Uuid) -> Result<(Uuid, String), LegacyMigrationError> {
531 let key = self
532 .source
533 .get_node_key_by_id(surface)
534 .ok_or_else(|| LegacyMigrationError("legacy claim endpoint is absent".into()))?;
535 let node = self.source.get_node(key).expect("surface key exists");
536 let url = node.primary_address().as_url_str().to_owned();
537 let resource = ResourceNode::new(&url);
538 if self.output.resource(resource.id()).is_none() {
539 let record = PersistedResourceRecord {
540 canonical_iri: resource.canonical_iri().into(),
541 facets: vec![],
542 };
543 if !self.output.set_resource_record(resource.id(), Some(record)) {
544 return Err(LegacyMigrationError(
545 "resource identity insertion was refused".into(),
546 ));
547 }
548 }
549 Ok((resource.id(), url))
550 }
551
552 fn first_origin(
553 &mut self,
554 pair: Pair,
555 payload: &EdgePayload,
556 id: &str,
557 baseline: bool,
558 ) -> Result<Origin, LegacyMigrationError> {
559 let statement = payload
560 .assertions()
561 .iter()
562 .find(|statement| statement.statement_id == id)
563 .expect("claim present");
564 let fixed = statement
565 .recognized_sub_kind
566 .map(|kind| super::built_in_relation_stratum(super::RelationKind::Semantic(kind)))
567 .or_else(|| super::built_in_predicate_stratum(&statement.predicate));
568 let nature = if let Some(nature) = fixed {
569 nature
570 } else if !baseline && self.authored_declarations.contains(&statement.predicate) {
571 self.source
574 .effective_predicate_stratum(&statement.predicate)
575 .unwrap_or(GraphStratum::Resource)
576 } else {
577 GraphStratum::Resource
578 };
579 if nature == GraphStratum::Surface {
580 return Ok(Origin {
581 surface: pair,
582 resource: None,
583 claim: statement.clone(),
584 });
585 }
586 let (current_from, from_url) = self.ensure_resource(pair.0)?;
587 let (current_to, to_url) = self.ensure_resource(pair.1)?;
588 let (from, to) = self
589 .resolutions
590 .get(id)
591 .copied()
592 .unwrap_or((current_from, current_to));
593 if baseline {
594 let edge = persisted_edge_for_ids(pair.0, pair.1, payload);
595 let statement = edge
596 .retained_assertions()
597 .iter()
598 .find(|statement| statement.statement_id == id)
599 .expect("statement serialized")
600 .clone();
601 self.add_note(
602 from,
603 LegacyMigrationNote {
604 from_surface_id: pair.0.to_string(),
605 to_surface_id: pair.1.to_string(),
606 from_resource_id: from.to_string(),
607 to_resource_id: to.to_string(),
608 from_url,
609 to_url,
610 statement,
611 uncertainty: "baseline_current_resources_without_mint_event".into(),
612 },
613 )?;
614 }
615 Ok(Origin {
616 surface: pair,
617 resource: Some((from, to)),
618 claim: statement.clone(),
619 })
620 }
621
622 fn add_note(
623 &mut self,
624 resource: Uuid,
625 note: LegacyMigrationNote,
626 ) -> Result<(), LegacyMigrationError> {
627 let mut record = self
628 .output
629 .resource_record(resource)
630 .expect("resource ensured");
631 let mut notes: Vec<LegacyMigrationNote> = record
632 .facets
633 .iter()
634 .find(|facet| facet.facet == LEGACY_RESOURCE_MIGRATION_FACET)
635 .map(|facet| serde_json::from_str(&facet.value_json))
636 .transpose()
637 .map_err(|error| {
638 LegacyMigrationError(format!("invalid prior migration note: {error}"))
639 })?
640 .unwrap_or_default();
641 if !notes.contains(¬e) {
642 notes.push(note);
643 }
644 record
645 .facets
646 .retain(|facet| facet.facet != LEGACY_RESOURCE_MIGRATION_FACET);
647 record.facets.push(PersistedResourceFacet {
648 facet: LEGACY_RESOURCE_MIGRATION_FACET.into(),
649 value_json: serde_json::to_string(¬es).expect("migration note serializes"),
650 });
651 self.output.set_resource_record(resource, Some(record));
652 Ok(())
653 }
654
655 fn first_aggregate_origin(
656 &mut self,
657 pair: Pair,
658 kind: super::RelationKind,
659 author: Option<&super::Author>,
660 ) -> Result<Pair, LegacyMigrationError> {
661 let (from, from_url) = self.ensure_resource(pair.0)?;
662 let (to, to_url) = self.ensure_resource(pair.1)?;
663 let note = LegacyAggregateMigrationNote {
664 from_surface_id: pair.0.to_string(),
665 to_surface_id: pair.1.to_string(),
666 from_resource_id: from.to_string(),
667 to_resource_id: to.to_string(),
668 from_url,
669 to_url,
670 kind,
671 author: author.cloned(),
672 uncertainty: if author.is_some() {
673 "legacy_pair_kind_identity_without_assertion_handle_or_time"
674 } else {
675 "baseline_current_resources_without_mint_event_handle_or_time"
676 }
677 .into(),
678 };
679 let mut record = self.output.resource_record(from).expect("resource ensured");
680 let mut notes: Vec<LegacyAggregateMigrationNote> = record
681 .facets
682 .iter()
683 .find(|facet| facet.facet == LEGACY_AGGREGATE_MIGRATION_FACET)
684 .map(|facet| serde_json::from_str(&facet.value_json))
685 .transpose()
686 .map_err(|error| {
687 LegacyMigrationError(format!("invalid aggregate migration note: {error}"))
688 })?
689 .unwrap_or_default();
690 if notes.contains(¬e) {
691 return Ok((from, to));
692 }
693 notes.push(note);
694 record
695 .facets
696 .retain(|facet| facet.facet != LEGACY_AGGREGATE_MIGRATION_FACET);
697 record.facets.push(PersistedResourceFacet {
698 facet: LEGACY_AGGREGATE_MIGRATION_FACET.into(),
699 value_json: serde_json::to_string(¬es).expect("aggregate note serializes"),
700 });
701 if !self.output.set_resource_record(from, Some(record)) {
702 return Err(LegacyMigrationError(
703 "aggregate migration note insertion was refused".into(),
704 ));
705 }
706 Ok((from, to))
707 }
708
709 fn sync(
710 &mut self,
711 before: &Pairs,
712 baseline: bool,
713 entry: Option<&AttributedDelta>,
714 ) -> Result<(), LegacyMigrationError> {
715 let after = surface_pairs(&self.source)?;
716 let previous = self.active.clone();
717 let aggregate_previous = self.aggregate_active.clone();
718 let present = statement_ids(&after.values().flatten().cloned().collect::<Vec<_>>());
719 self.active.retain(|id, _| present.contains(id));
720 let mut seen = BTreeMap::new();
721 let mut next = BTreeMap::<String, Membership>::new();
722 let mut aggregate_next = BTreeMap::<(Pair, u32), Membership>::new();
723 for (&pair, edges) in &after {
724 let old_ids = statement_ids(before.get(&pair).map(Vec::as_slice).unwrap_or(&[]));
725 let old_kinds: BTreeSet<_> = before
726 .get(&pair)
727 .into_iter()
728 .flatten()
729 .flat_map(|edge| aggregate_kinds(&payload_from_persisted(edge)))
730 .map(super::RelationKind::tag)
731 .collect();
732 for edge in edges {
733 let mut payload = payload_from_persisted(edge);
734 for kind in aggregate_kinds(&payload).into_iter().filter(|kind| {
735 super::built_in_relation_stratum(*kind) == GraphStratum::Resource
736 }) {
737 let key = (pair, kind.tag());
738 if !self.aggregate_origins.contains_key(&key) {
739 let proven_author = entry
740 .filter(|entry| delta_introduces_member(&entry.delta, pair, kind))
741 .map(|entry| &entry.author);
742 let resource = self.first_aggregate_origin(pair, kind, proven_author)?;
743 self.aggregate_origins.insert(key, resource);
744 }
745 if self.aggregate_active.contains_key(&key) || !old_kinds.contains(&kind.tag())
746 {
747 let resource = self.aggregate_origins[&key];
748 let mut claim = EdgePayload::new();
749 let statement = payload
755 .assertions()
756 .iter()
757 .find(|statement| {
758 statement.is_held()
759 && statement.relation_kind() == kind
760 && statement.statement_id.starts_with(
761 super::legacy_family_attribution::LEGACY_FAMILY_ASSERTION_ID_PREFIX,
762 )
763 })
764 .expect("legacy aggregate kind has its deterministic source record")
765 .clone();
766 claim.assertions.statements.push(statement);
767 claim.assertions.rebuild_compat();
768 aggregate_next
769 .entry(key)
770 .or_insert_with(|| Membership {
771 surface: pair,
772 resource,
773 edges: Vec::new(),
774 })
775 .edges
776 .push(persisted_edge_for_ids(resource.0, resource.1, &claim));
777 }
778 }
779 {
780 let semantic = &mut payload.assertions;
781 for statement in &mut semantic.statements {
782 statement.normalize_legacy_asserter();
783 }
784 }
785 let ids: Vec<_> = payload
786 .assertions()
787 .iter()
788 .map(|statement| statement.statement_id.clone())
789 .collect();
790 for id in ids {
791 let statement = payload
792 .assertions()
793 .iter()
794 .find(|statement| statement.statement_id == id)
795 .expect("claim present");
796 if let Some((old_pair, old_statement)) =
797 seen.insert(id.clone(), (pair, statement.clone()))
798 && (old_pair != pair || old_statement != *statement)
799 {
800 return Err(LegacyMigrationError(format!(
801 "conflicting legacy statement handle {id}"
802 )));
803 }
804 if !self.origins.contains_key(&id) {
805 let origin = self.first_origin(pair, &payload, &id, baseline)?;
806 self.origins.insert(id.clone(), origin);
807 }
808 let origin = &self.origins[&id];
809 if origin.surface != pair {
810 return Err(LegacyMigrationError(format!(
811 "legacy handle {id} changed original endpoints"
812 )));
813 }
814 if !origin.claim.same_claim_as(statement) {
815 return Err(LegacyMigrationError(format!(
816 "legacy handle {id} changed its original claim identity"
817 )));
818 }
819 if let Some(resource) = origin.resource
820 && !(id.starts_with(super::legacy_family_attribution::LEGACY_FAMILY_ASSERTION_ID_PREFIX)
826 && aggregate_kinds(&payload)
827 .contains(&statement.relation_kind()))
828 && (self.active.contains_key(&id) || !old_ids.contains(&id))
829 {
830 let mut claim = EdgePayload::new();
831 claim.assertions = payload.assertions.clone();
832 let semantic = &mut claim.assertions;
833 semantic
834 .statements
835 .retain(|statement| statement.statement_id == id);
836 semantic.rebuild_compat();
837 let edge = persisted_edge_for_ids(resource.0, resource.1, &claim);
838 let held = next.entry(id).or_insert_with(|| Membership {
839 surface: pair,
840 resource,
841 edges: Vec::new(),
842 });
843 if held.edges.contains(&edge) {
844 self.note_deduped_copy(pair, resource, &edge)?;
845 } else {
846 held.edges.push(edge);
847 }
848 }
849 }
850 }
851 }
852 self.active = next;
853 self.aggregate_active = aggregate_next;
854 for pair in before
857 .keys()
858 .chain(after.keys())
859 .copied()
860 .collect::<BTreeSet<_>>()
861 {
862 let edges = after.get(&pair).map(Vec::as_slice).unwrap_or(&[]);
863 let semantic_filtered = filter_edges(pair, edges, |id| {
864 self.origins
865 .get(id)
866 .is_some_and(|origin| origin.resource.is_some())
867 });
868 let (filtered, copies) =
869 copies::split_copies(filter_resource_aggregates(pair, &semantic_filtered));
870 let (Some(from), Some(to)) = (
871 self.output.get_node_key_by_id(pair.0),
872 self.output.get_node_key_by_id(pair.1),
873 ) else {
874 continue;
875 };
876 for copy in &copies {
877 self.note_deduped_surface_copy(pair, copy)?;
878 }
879 if self.output.persisted_edges_between(from, to) != filtered {
880 self.output.set_edges_between(
882 from,
883 to,
884 &filtered.iter().rev().cloned().collect::<Vec<_>>(),
885 );
886 }
887 }
888 let mut affected: BTreeSet<_> = previous
889 .keys()
890 .chain(self.active.keys())
891 .filter(|id| previous.get(*id) != self.active.get(*id))
892 .flat_map(|id| {
893 previous
894 .get(id)
895 .into_iter()
896 .chain(self.active.get(id))
897 .map(|member| member.resource)
898 })
899 .collect();
900 affected.extend(
901 aggregate_previous
902 .keys()
903 .chain(self.aggregate_active.keys())
904 .filter(|key| aggregate_previous.get(*key) != self.aggregate_active.get(*key))
905 .flat_map(|key| {
906 aggregate_previous
907 .get(key)
908 .into_iter()
909 .chain(self.aggregate_active.get(key))
910 .map(|member| member.resource)
911 }),
912 );
913 for pair in affected {
914 let existing = self.output.persisted_resource_edges_between(pair.0, pair.1);
915 let mut desired = existing.clone();
916 for edge in previous
920 .values()
921 .filter(|member| member.resource == pair)
922 .flat_map(|member| &member.edges)
923 {
924 if let Some(index) = desired.iter().position(|held| held == edge) {
925 desired.remove(index);
926 }
927 }
928 for edge in aggregate_previous
929 .values()
930 .filter(|member| member.resource == pair)
931 .flat_map(|member| &member.edges)
932 {
933 if let Some(index) = desired.iter().position(|held| held == edge) {
934 desired.remove(index);
935 }
936 }
937 desired.extend(
938 self.active
939 .values()
940 .filter(|member| member.resource == pair)
941 .flat_map(|member| member.edges.iter().cloned()),
942 );
943 desired.extend(
944 self.aggregate_active
945 .values()
946 .filter(|member| member.resource == pair)
947 .flat_map(|member| member.edges.iter().cloned()),
948 );
949 if desired != existing
950 && !self
951 .output
952 .set_resource_edges_between(pair.0, pair.1, &desired)
953 {
954 return Err(LegacyMigrationError(format!(
955 "resource handle collision on {} -> {}",
956 pair.0, pair.1
957 )));
958 }
959 }
960 self.dedupe_resource_copies()?;
961 let surfaces: Vec<_> = self.source.nodes().map(|(_, node)| node.id).collect();
963 for surface in surfaces {
964 let source_key = self
965 .source
966 .get_node_key_by_id(surface)
967 .expect("surface exists");
968 if self.source.shown_resource_id(source_key).is_some() {
969 continue;
970 }
971 let (resource, _) = self.ensure_resource(surface)?;
972 self.output.set_shown_resource(surface, Some(resource));
973 }
974 Ok(())
975 }
976}
977
978fn parse_id(id: &str) -> Result<Uuid, LegacyMigrationError> {
979 Uuid::parse_str(id).map_err(|error| LegacyMigrationError(error.to_string()))
980}
981
982fn historical_statement_stratum(
983 graph: &Graph,
984 statement: &super::SemanticStatement,
985) -> GraphStratum {
986 statement
987 .recognized_sub_kind
988 .map(|kind| super::built_in_relation_stratum(super::RelationKind::Semantic(kind)))
989 .or_else(|| super::built_in_predicate_stratum(&statement.predicate))
990 .unwrap_or_else(|| {
991 graph
992 .effective_predicate_stratum(&statement.predicate)
993 .unwrap_or(GraphStratum::Resource)
994 })
995}
996
997fn aggregate_kinds(payload: &EdgePayload) -> Vec<super::RelationKind> {
998 let mut kinds: Vec<_> = payload
999 .held_assertions()
1000 .filter(|statement| {
1001 statement
1002 .statement_id
1003 .starts_with(super::legacy_family_attribution::LEGACY_FAMILY_ASSERTION_ID_PREFIX)
1004 })
1005 .map(|statement| statement.relation_kind())
1006 .filter(|kind| {
1007 matches!(
1008 kind,
1009 super::RelationKind::Containment(_)
1010 | super::RelationKind::Imported(_)
1011 | super::RelationKind::Provenance(_)
1012 )
1013 })
1014 .collect();
1015 kinds.sort_by_key(|kind| kind.tag());
1016 kinds.dedup();
1017 kinds
1018}
1019
1020fn filter_resource_aggregates(pair: Pair, edges: &[PersistedEdge]) -> Vec<PersistedEdge> {
1021 edges
1022 .iter()
1023 .filter_map(|edge| {
1024 let mut payload = payload_from_persisted(edge);
1025 let kinds: Vec<_> = aggregate_kinds(&payload)
1026 .into_iter()
1027 .filter(|kind| super::built_in_relation_stratum(*kind) == GraphStratum::Resource)
1028 .collect();
1029 if !kinds.is_empty() {
1030 payload.assertions.statements.retain(|statement| {
1031 !statement.statement_id.starts_with(
1032 super::legacy_family_attribution::LEGACY_FAMILY_ASSERTION_ID_PREFIX,
1033 ) || !kinds.contains(&statement.relation_kind())
1034 });
1035 payload.assertions.rebuild_compat();
1036 }
1037 (!payload.is_empty()).then(|| persisted_edge_for_ids(pair.0, pair.1, &payload))
1038 })
1039 .collect()
1040}
1041
1042fn record_value(
1043 record: &PersistedResourceRecord,
1044) -> Result<(String, BTreeMap<String, serde_json::Value>), LegacyMigrationError> {
1045 let mut facets = BTreeMap::new();
1046 for facet in &record.facets {
1047 let value = serde_json::from_str(&facet.value_json)
1048 .map_err(|error| LegacyMigrationError(error.to_string()))?;
1049 if facets.insert(facet.facet.clone(), value).is_some() {
1050 return Err(LegacyMigrationError(
1051 "duplicate typed resource facet".into(),
1052 ));
1053 }
1054 }
1055 Ok((record.canonical_iri.clone(), facets))
1056}
1057fn current_resource_pair(graph: &Graph, pair: Pair) -> Result<Pair, LegacyMigrationError> {
1058 let resource = |surface| {
1059 graph
1060 .get_node_by_id(surface)
1061 .map(|(_, node)| ResourceNode::new(node.primary_address().as_url_str()).id())
1062 .ok_or_else(|| LegacyMigrationError("legacy endpoint is absent".into()))
1063 };
1064 Ok((resource(pair.0)?, resource(pair.1)?))
1065}
1066fn raw_semantic_edit(delta: &CapturedDelta) -> bool {
1067 matches!(
1068 delta,
1069 CapturedDelta::ReplayAssertRelationByIds {
1070 assertion: super::EdgeAssertion::Semantic { .. },
1071 ..
1072 } | CapturedDelta::ReplayAssertSemanticPredicateByIds { .. }
1073 | CapturedDelta::ReplaySetEdgeSemanticPredicateByIds { .. }
1074 )
1075}
1076
1077fn delta_introduces_member(delta: &CapturedDelta, pair: Pair, kind: super::RelationKind) -> bool {
1081 match delta {
1082 CapturedDelta::ReplayAssertRelationByIds {
1083 from_id,
1084 to_id,
1085 assertion,
1086 } => {
1087 let asserted_kind = match assertion {
1088 super::EdgeAssertion::Semantic { sub_kind, .. } => {
1089 super::RelationKind::Semantic(*sub_kind)
1090 },
1091 super::EdgeAssertion::Containment { sub_kind } => {
1092 super::RelationKind::Containment(*sub_kind)
1093 },
1094 super::EdgeAssertion::Arrangement { sub_kind } => {
1095 super::RelationKind::Arrangement(*sub_kind)
1096 },
1097 super::EdgeAssertion::Imported { sub_kind } => {
1098 super::RelationKind::Imported(*sub_kind)
1099 },
1100 super::EdgeAssertion::Provenance { sub_kind } => {
1101 super::RelationKind::Provenance(*sub_kind)
1102 },
1103 };
1104 (parse_id(from_id).ok(), parse_id(to_id).ok()) == (Some(pair.0), Some(pair.1))
1105 && asserted_kind == kind
1106 },
1107 _ => false,
1108 }
1109}
1110
1111fn surface_pairs(graph: &Graph) -> Result<Pairs, LegacyMigrationError> {
1112 pairs(&graph.to_snapshot().edges)
1113}
1114fn pairs(edges: &[PersistedEdge]) -> Result<Pairs, LegacyMigrationError> {
1115 let mut pairs = Pairs::new();
1116 for edge in edges {
1117 pairs
1118 .entry((parse_id(&edge.from_node_id)?, parse_id(&edge.to_node_id)?))
1119 .or_default()
1120 .push(edge.clone());
1121 }
1122 Ok(pairs)
1123}
1124fn statement_ids(edges: &[PersistedEdge]) -> BTreeSet<String> {
1125 edges
1126 .iter()
1127 .flat_map(|edge| edge.retained_assertions())
1128 .map(|statement| statement.statement_id.clone())
1129 .collect()
1130}
1131fn filter_edges(
1132 pair: Pair,
1133 edges: &[PersistedEdge],
1134 remove: impl Fn(&str) -> bool,
1135) -> Vec<PersistedEdge> {
1136 edges
1137 .iter()
1138 .filter_map(|edge| {
1139 let mut payload = payload_from_persisted(edge);
1140 let ids: Vec<_> = payload
1141 .assertions()
1142 .iter()
1143 .filter(|statement| remove(&statement.statement_id))
1144 .map(|statement| statement.statement_id.clone())
1145 .collect();
1146 for id in ids {
1147 payload.compact_semantic_statement(&id);
1148 }
1149 (!payload.is_empty()).then(|| persisted_edge_for_ids(pair.0, pair.1, &payload))
1150 })
1151 .collect()
1152}
1153fn legacy_edge_edit(delta: &CapturedDelta) -> bool {
1154 matches!(
1155 delta,
1156 CapturedDelta::ReplayAssertRelationByIds { .. }
1157 | CapturedDelta::ReplayRetractRelationsByIds { .. }
1158 | CapturedDelta::ReplayAppendTraversalByIds { .. }
1159 | CapturedDelta::ReplaySetEdgeSemanticPredicateByIds { .. }
1160 | CapturedDelta::ReplayAssertSemanticPredicateByIds { .. }
1161 | CapturedDelta::ReplaySetEdgesByIds { .. }
1162 )
1163}
1164fn typed_resource_pair(delta: &CapturedDelta) -> Result<Option<Pair>, LegacyMigrationError> {
1165 match delta {
1166 CapturedDelta::ReplaySetResourceEdgesByIds {
1167 from_resource_id,
1168 to_resource_id,
1169 ..
1170 } => Ok(Some((
1171 parse_id(from_resource_id)?,
1172 parse_id(to_resource_id)?,
1173 ))),
1174 _ => Ok(None),
1175 }
1176}
1177
1178fn lifecycle_surface(delta: &CapturedDelta) -> Result<Option<Uuid>, LegacyMigrationError> {
1179 match delta {
1180 CapturedDelta::ReplayAddNodeWithIdIfMissing { id: node_id, .. }
1181 | CapturedDelta::ReplaySetNodeUrlById { node_id, .. }
1182 | CapturedDelta::ReplayNavigateNodeById { node_id, .. }
1183 | CapturedDelta::ReplayNodeHistoryBackById { node_id, .. }
1184 | CapturedDelta::ReplayNodeHistoryForwardById { node_id, .. } => {
1185 Ok(Some(parse_id(node_id)?))
1186 },
1187 _ => Ok(None),
1188 }
1189}
1190
1191fn effects_between(
1192 before: &GraphSnapshot,
1193 after: &GraphSnapshot,
1194 after_facets: &super::node_facets::NodeFacetStore,
1195) -> Result<Vec<CapturedDelta>, LegacyMigrationError> {
1196 let mut effects = Vec::new();
1197 let before_nodes: BTreeMap<_, _> = before
1198 .nodes
1199 .iter()
1200 .map(|node| (node.node_id.as_str(), node))
1201 .collect();
1202 for node in &after.nodes {
1204 if let Some(previous) = before_nodes.get(node.node_id.as_str()) {
1205 let mut removed = false;
1206 for tag in &previous.tags {
1207 if !node.tags.contains(tag) {
1208 removed = true;
1209 effects.push(CapturedDelta::ReplayRemoveNodeTagById {
1210 node_id: node.node_id.clone(),
1211 tag: tag.clone(),
1212 });
1213 }
1214 }
1215 if removed {
1216 let facet = super::node_facets::PRESENTATION_TAGS;
1219 let id = parse_id(&node.node_id)?;
1220 effects.push(
1221 match after_facets.get(&id, &chartulary::FacetId::new(facet)) {
1222 Some(value) => CapturedDelta::ReplaySetNodeFacetById {
1223 node_id: node.node_id.clone(),
1224 facet: facet.into(),
1225 value_json: serde_json::to_string(value).expect("facet serializes"),
1226 },
1227 None => CapturedDelta::ReplayRemoveNodeFacetById {
1228 node_id: node.node_id.clone(),
1229 facet: facet.into(),
1230 },
1231 },
1232 );
1233 }
1234 }
1235 }
1236 let before_records: BTreeMap<_, _> = before
1237 .resources
1238 .iter()
1239 .map(|record| (ResourceNode::for_term(&record.canonical_iri).id(), record))
1240 .collect();
1241 let after_records: BTreeMap<_, _> = after
1242 .resources
1243 .iter()
1244 .map(|record| (ResourceNode::for_term(&record.canonical_iri).id(), record))
1245 .collect();
1246 let mut seen_records = BTreeSet::new();
1248 for id in after
1249 .resources
1250 .iter()
1251 .chain(&before.resources)
1252 .map(|record| ResourceNode::for_term(&record.canonical_iri).id())
1253 .filter(|id| seen_records.insert(*id))
1254 {
1255 if before_records.get(&id) != after_records.get(&id) {
1256 effects.push(CapturedDelta::ReplaySetResourceRecordById {
1257 resource_id: id.to_string(),
1258 record: after_records.get(&id).map(|record| (*record).clone()),
1259 });
1260 }
1261 }
1262 let before_shown: BTreeMap<_, _> = before
1263 .shown_resources
1264 .iter()
1265 .map(|shown| (&shown.surface_id, &shown.resource_id))
1266 .collect();
1267 let after_shown: BTreeMap<_, _> = after
1268 .shown_resources
1269 .iter()
1270 .map(|shown| (&shown.surface_id, &shown.resource_id))
1271 .collect();
1272 for surface in before_shown
1273 .keys()
1274 .chain(after_shown.keys())
1275 .copied()
1276 .collect::<BTreeSet<_>>()
1277 {
1278 if before_shown.get(surface) != after_shown.get(surface) {
1279 effects.push(CapturedDelta::ReplaySetShownResourceById {
1280 surface_id: surface.clone(),
1281 resource_id: after_shown.get(surface).map(|id| (*id).clone()),
1282 });
1283 }
1284 }
1285 for (resource, before, after) in [
1286 (false, &before.edges, &after.edges),
1287 (true, &before.resource_edges, &after.resource_edges),
1288 ] {
1289 let before = pairs(before)?;
1290 let after = pairs(after)?;
1291 for pair in before
1292 .keys()
1293 .chain(after.keys())
1294 .copied()
1295 .collect::<BTreeSet<_>>()
1296 {
1297 if before.get(&pair) != after.get(&pair) {
1298 let edges = after.get(&pair).cloned().unwrap_or_default();
1299 effects.push(if resource {
1300 CapturedDelta::ReplaySetResourceEdgesByIds {
1301 from_resource_id: pair.0.to_string(),
1302 to_resource_id: pair.1.to_string(),
1303 edges,
1304 }
1305 } else {
1306 CapturedDelta::ReplaySetEdgesByIds {
1307 from_id: pair.0.to_string(),
1308 to_id: pair.1.to_string(),
1309 edges: edges.into_iter().rev().collect(),
1310 }
1311 });
1312 }
1313 }
1314 }
1315 Ok(effects)
1316}
1317
1318fn facet_effects_between(
1319 before: &super::node_facets::NodeFacetStore,
1320 after: &super::node_facets::NodeFacetStore,
1321) -> Vec<CapturedDelta> {
1322 let values = |store: &super::node_facets::NodeFacetStore| -> BTreeMap<_, _> {
1323 store
1324 .iter()
1325 .flat_map(|(node, facets)| {
1326 facets
1327 .iter()
1328 .map(move |(facet, value)| ((*node, facet.as_str().to_owned()), value.clone()))
1329 })
1330 .collect()
1331 };
1332 let before = values(before);
1333 let after = values(after);
1334 before
1335 .keys()
1336 .chain(after.keys())
1337 .collect::<BTreeSet<_>>()
1338 .into_iter()
1339 .filter(|key| before.get(*key) != after.get(*key))
1340 .map(|(node, facet)| match after.get(&(*node, facet.clone())) {
1341 Some(value) => CapturedDelta::ReplaySetNodeFacetById {
1342 node_id: node.to_string(),
1343 facet: facet.clone(),
1344 value_json: serde_json::to_string(value).expect("facet value serializes"),
1345 },
1346 None => CapturedDelta::ReplayRemoveNodeFacetById {
1347 node_id: node.to_string(),
1348 facet: facet.clone(),
1349 },
1350 })
1351 .collect()
1352}
1353
1354#[cfg(test)]
1355mod tests {
1356 use super::super::{
1357 Author, EdgeAssertion, GraphJournal, ImportedSubKind, ProvenanceSubKind, SemanticStatement,
1358 SemanticSubKind, Seq, predicate_iri, replay_captured_deltas_onto,
1359 };
1360 use super::*;
1361 use crate::types::GraphScope;
1362 use euclid::default::Point2D;
1363
1364 fn baseline(urls: &[&str]) -> Graph {
1365 let mut graph = Graph::new();
1366 for (index, url) in urls.iter().enumerate() {
1367 graph.add_node_with_id(
1368 Uuid::from_u128(index as u128 + 1),
1369 (*url).into(),
1370 Point2D::zero(),
1371 );
1372 }
1373 graph
1374 }
1375
1376 fn payload(id: &str, predicate: &str, source: Option<&str>) -> EdgePayload {
1377 let mut payload = EdgePayload::new();
1378 payload.push_persisted_semantic_statement(SemanticStatement {
1379 statement_id: id.into(),
1380 predicate: predicate.into(),
1381 recognized_sub_kind: super::super::sub_kind_from_iri(predicate),
1382 label: Some(format!("label-{id}")),
1383 graph_scope: GraphScope::User,
1384 provenance_iri: source.map(str::to_owned),
1385 asserted_at_ms: Some(100),
1386 first_asserted_ms: Some(100),
1387 withdrawn: None,
1388 basis: Default::default(),
1389 });
1390 payload
1391 }
1392
1393 fn exact(from: u128, to: u128, payload: &EdgePayload) -> CapturedDelta {
1394 let pair = (Uuid::from_u128(from), Uuid::from_u128(to));
1395 CapturedDelta::ReplaySetEdgesByIds {
1396 from_id: pair.0.to_string(),
1397 to_id: pair.1.to_string(),
1398 edges: vec![persisted_edge_for_ids(pair.0, pair.1, payload)],
1399 }
1400 }
1401
1402 fn legacy_sidecar(from: Uuid, to: Uuid, kinds: &[super::super::RelationKind]) -> PersistedEdge {
1403 use super::super::RelationKind;
1404 use crate::persistence::{
1405 PersistedContainmentSubKind as C, PersistedImportedSubKind as I,
1406 PersistedProvenanceSubKind as P,
1407 };
1408
1409 let mut containment = Vec::new();
1410 let mut imported = Vec::new();
1411 let mut provenance = Vec::new();
1412 for kind in kinds {
1413 match kind {
1414 RelationKind::Containment(kind) => containment.push(match kind {
1415 super::super::ContainmentSubKind::UrlPath => C::UrlPath,
1416 super::super::ContainmentSubKind::Domain => C::Domain,
1417 super::super::ContainmentSubKind::FileSystem => C::FileSystem,
1418 super::super::ContainmentSubKind::UserFolder => C::UserFolder,
1419 super::super::ContainmentSubKind::ClipSource => C::ClipSource,
1420 super::super::ContainmentSubKind::NotebookSection => C::NotebookSection,
1421 super::super::ContainmentSubKind::CollectionMember => C::CollectionMember,
1422 }),
1423 RelationKind::Imported(kind) => imported.push(match kind {
1424 super::super::ImportedSubKind::BookmarkFolder => I::BookmarkFolder,
1425 super::super::ImportedSubKind::HistoryImport => I::HistoryImport,
1426 super::super::ImportedSubKind::SessionImport => I::SessionImport,
1427 super::super::ImportedSubKind::RssMembership => I::RssMembership,
1428 super::super::ImportedSubKind::FileSystemImport => I::FileSystemImport,
1429 super::super::ImportedSubKind::ArchiveMembership => I::ArchiveMembership,
1430 super::super::ImportedSubKind::SharedCollection => I::SharedCollection,
1431 }),
1432 RelationKind::Provenance(kind) => provenance.push(match kind {
1433 super::super::ProvenanceSubKind::ClippedFrom => P::ClippedFrom,
1434 super::super::ProvenanceSubKind::ExcerptedFrom => P::ExcerptedFrom,
1435 super::super::ProvenanceSubKind::SummarizedFrom => P::SummarizedFrom,
1436 super::super::ProvenanceSubKind::TranslatedFrom => P::TranslatedFrom,
1437 super::super::ProvenanceSubKind::RewrittenFrom => P::RewrittenFrom,
1438 super::super::ProvenanceSubKind::GeneratedFrom => P::GeneratedFrom,
1439 super::super::ProvenanceSubKind::ExtractedFrom => P::ExtractedFrom,
1440 super::super::ProvenanceSubKind::ImportedFromSource => P::ImportedFromSource,
1441 super::super::ProvenanceSubKind::CopiedFrom => P::CopiedFrom,
1442 super::super::ProvenanceSubKind::MergedFrom => P::MergedFrom,
1443 }),
1444 _ => panic!("test legacy fixture only encodes the three old family sidecars"),
1445 }
1446 }
1447 PersistedEdge {
1448 from_node_id: from.to_string(),
1449 to_node_id: to.to_string(),
1450 families: Vec::new(),
1451 semantic: None,
1452 traversal: None,
1453 containment: (!containment.is_empty()).then_some(PersistedContainmentEdgeData {
1454 sub_kinds: containment,
1455 }),
1456 arrangement: None,
1457 imported: (!imported.is_empty()).then_some(PersistedImportedEdgeData {
1458 sub_kinds: imported,
1459 }),
1460 provenance: (!provenance.is_empty()).then_some(PersistedProvenanceEdgeData {
1461 sub_kinds: provenance,
1462 }),
1463 assertions: None,
1464 }
1465 }
1466
1467 fn exact_legacy(from: u128, to: u128, kind: super::super::RelationKind) -> CapturedDelta {
1468 let (from_id, to_id) = (Uuid::from_u128(from), Uuid::from_u128(to));
1469 CapturedDelta::ReplaySetEdgesByIds {
1470 from_id: from_id.to_string(),
1471 to_id: to_id.to_string(),
1472 edges: vec![legacy_sidecar(from_id, to_id, &[kind])],
1473 }
1474 }
1475
1476 fn clear(from: u128, to: u128) -> CapturedDelta {
1477 CapturedDelta::ReplaySetEdgesByIds {
1478 from_id: Uuid::from_u128(from).to_string(),
1479 to_id: Uuid::from_u128(to).to_string(),
1480 edges: vec![],
1481 }
1482 }
1483
1484 fn resource_pair(a: &str, b: &str) -> Pair {
1485 (ResourceNode::new(a).id(), ResourceNode::new(b).id())
1486 }
1487
1488 fn aggregate_assertion(kind: super::super::RelationKind) -> super::super::EdgeAssertion {
1489 match kind {
1490 super::super::RelationKind::Containment(sub_kind) => {
1491 super::super::EdgeAssertion::Containment { sub_kind }
1492 },
1493 super::super::RelationKind::Imported(sub_kind) => {
1494 super::super::EdgeAssertion::Imported { sub_kind }
1495 },
1496 super::super::RelationKind::Provenance(sub_kind) => {
1497 super::super::EdgeAssertion::Provenance { sub_kind }
1498 },
1499 _ => unreachable!("fixture includes the three nonsemantic families"),
1500 }
1501 }
1502
1503 fn persisted_aggregate_tags(edges: &[PersistedEdge]) -> Vec<u32> {
1504 edges
1505 .iter()
1506 .flat_map(|edge| aggregate_kinds(&payload_from_persisted(edge)))
1507 .map(super::super::RelationKind::tag)
1508 .collect()
1509 }
1510
1511 #[test]
1512 fn legacy_resource_migration_exact_facet_effects_freeze_birth_clock_and_unknown_values() {
1513 let baseline = baseline(&["https://a.test/", "https://b.test/"]);
1514 let born = Uuid::from_u128(3);
1515 let mut journal = GraphJournal::new();
1516 let author = Author::person("legacy-author");
1517 journal.record_as(
1518 author.clone(),
1519 CapturedDelta::ReplayAddNodeWithIdIfMissing {
1520 id: born.to_string(),
1521 url: "https://c.test/".into(),
1522 position: [0.0, 0.0],
1523 },
1524 );
1525 journal.record_as(
1526 author.clone(),
1527 CapturedDelta::ReplayAssertRelationByIds {
1528 from_id: Uuid::from_u128(1).to_string(),
1529 to_id: born.to_string(),
1530 assertion: EdgeAssertion::Semantic {
1531 sub_kind: SemanticSubKind::UserGrouped,
1532 label: None,
1533 },
1534 },
1535 );
1536 journal.record_as(
1537 author.clone(),
1538 CapturedDelta::ReplaySetNodeFacetById {
1539 node_id: born.to_string(),
1540 facet: "foreign.opaque".into(),
1541 value_json: r#"{"raw":"KeepCase#Exact","nested":[null,17,{"x":true}]}"#.into(),
1542 },
1543 );
1544 journal.record_as(
1545 author.clone(),
1546 CapturedDelta::ReplaySetNodeFacetById {
1547 node_id: born.to_string(),
1548 facet: "foreign.removed".into(),
1549 value_json: "[1,2]".into(),
1550 },
1551 );
1552 journal.record_as(
1553 author,
1554 CapturedDelta::ReplayRemoveNodeFacetById {
1555 node_id: born.to_string(),
1556 facet: "foreign.removed".into(),
1557 },
1558 );
1559 let input = serde_json::to_vec(journal.entries()).unwrap();
1560 let translated = migrate_legacy_prefix(&baseline, journal.entries()).unwrap();
1561 assert!(translated.entry_effects[0].iter().any(|delta| matches!(delta,
1562 CapturedDelta::ReplaySetNodeFacetById { node_id, facet, .. }
1563 if node_id == &born.to_string() && facet == super::super::node_facets::VISIT_HISTORY)));
1564 assert!(
1565 translated.entry_effects[4]
1566 .iter()
1567 .any(|delta| matches!(delta,
1568 CapturedDelta::ReplayRemoveNodeFacetById { node_id, facet }
1569 if node_id == &born.to_string() && facet == "foreign.removed"))
1570 );
1571 let snapshot_value = |graph: &Graph| {
1572 let mut value = serde_json::to_value(graph.to_snapshot()).unwrap();
1573 value["timestamp_secs"] = serde_json::json!(0);
1574 value
1575 };
1576 let mut recreated = baseline.clone();
1577 replay_captured_deltas_onto(&mut recreated, translated.baseline_effects.clone());
1578 for effects in &translated.entry_effects {
1579 replay_captured_deltas_onto(&mut recreated, effects.iter().cloned());
1580 }
1581 assert_eq!(
1582 snapshot_value(&recreated),
1583 snapshot_value(&translated.graph)
1584 );
1585 assert_eq!(recreated.facets(), translated.graph.facets());
1586 let mut reordered_baseline = translated.baseline_effects.clone();
1587 let records: Vec<_> = reordered_baseline
1588 .iter()
1589 .enumerate()
1590 .filter_map(|(index, delta)| {
1591 matches!(
1592 delta,
1593 CapturedDelta::ReplaySetResourceRecordById {
1594 record: Some(_),
1595 ..
1596 }
1597 )
1598 .then_some(index)
1599 })
1600 .collect();
1601 assert_eq!(records.len(), 2);
1602 for (destination, source) in records.iter().zip(records.iter().rev()) {
1603 reordered_baseline[*destination] = translated.baseline_effects[*source].clone();
1604 }
1605 let mut reordered = baseline.clone();
1606 replay_captured_deltas_onto(&mut reordered, reordered_baseline);
1607 for effects in &translated.entry_effects {
1608 replay_captured_deltas_onto(&mut reordered, effects.iter().cloned());
1609 }
1610 assert_eq!(
1611 reordered.to_snapshot().edges,
1612 translated.graph.to_snapshot().edges,
1613 "changing record creation order does not change the carried statement handle"
1614 );
1615 assert_ne!(
1616 reordered.to_snapshot().resources,
1617 translated.graph.to_snapshot().resources,
1618 "exact frozen reconstruction also preserves resource record order"
1619 );
1620 let mut fresh_clock = baseline.clone();
1621 replay_captured_deltas_onto(&mut fresh_clock, translated.baseline_effects.clone());
1622 for effects in &translated.entry_effects {
1623 replay_captured_deltas_onto(&mut fresh_clock, effects.iter().filter(|delta| !matches!(delta,
1624 CapturedDelta::ReplaySetNodeFacetById { node_id, facet, .. }
1625 if node_id == &born.to_string() && facet == super::super::node_facets::VISIT_HISTORY)).cloned());
1626 }
1627 let key = translated.graph.get_node_key_by_id(born).unwrap();
1628 let frozen_ms = translated
1629 .graph
1630 .node_last_visited(key)
1631 .unwrap()
1632 .duration_since(std::time::UNIX_EPOCH)
1633 .unwrap()
1634 .as_millis() as u64;
1635 replay_captured_deltas_onto(
1637 &mut fresh_clock,
1638 [CapturedDelta::ReplayTouchNodeLastVisitedById {
1639 node_id: born.to_string(),
1640 timestamp_ms: frozen_ms.saturating_add(1),
1641 }],
1642 );
1643 assert_eq!(
1644 snapshot_value(&fresh_clock),
1645 snapshot_value(&translated.graph),
1646 "the snapshot alone does not include the authoritative visit facet"
1647 );
1648 assert_ne!(
1649 fresh_clock.facets(),
1650 translated.graph.facets(),
1651 "an unfrozen replay clock is observably different"
1652 );
1653 assert_eq!(serde_json::to_vec(journal.entries()).unwrap(), input);
1654 assert_eq!(
1655 statement_ids(&recreated.to_snapshot().edges),
1656 statement_ids(&translated.graph.to_snapshot().edges)
1657 );
1658 }
1659
1660 #[test]
1661 fn legacy_resource_migration_surface_placed_claims_need_no_resource_origin_resolution() {
1662 let baseline = baseline(&["https://a.test/old", "https://b.test/"]);
1663 for predicate in [
1664 predicate_iri(SemanticSubKind::UserGrouped),
1665 "https://vocab.test/custom",
1666 ] {
1667 let mut entries = Vec::new();
1668 let author = Author::person("mint-author");
1669 entries.push(AttributedDelta {
1670 author: author.clone(),
1671 delta: CapturedDelta::ReplayAssertSemanticPredicateByIds {
1672 from_id: Uuid::from_u128(1).to_string(),
1673 to_id: Uuid::from_u128(2).to_string(),
1674 predicate: predicate.into(),
1675 },
1676 });
1677 entries.push(AttributedDelta {
1678 author: author.clone(),
1679 delta: CapturedDelta::ReplaySetNodeUrlById {
1680 node_id: Uuid::from_u128(1).to_string(),
1681 new_url: "https://a.test/new".into(),
1682 },
1683 });
1684 if predicate.starts_with("https://vocab.test/") {
1685 let mut declarations = Graph::new();
1686 declarations
1687 .declare_predicate(predicate, GraphStratum::Surface)
1688 .unwrap();
1689 let id = ResourceNode::for_term(predicate).id();
1690 entries.push(AttributedDelta {
1691 author: author.clone(),
1692 delta: CapturedDelta::ReplaySetResourceRecordById {
1693 resource_id: id.to_string(),
1694 record: declarations.resource_record(id),
1695 },
1696 });
1697 }
1698 let mut carried = payload("surface-carried", predicate, Some(&author.asserter_iri()));
1699 carried.assertions.statements[0].graph_scope = GraphScope::Default;
1700 entries.push(AttributedDelta {
1701 author,
1702 delta: exact(1, 2, &carried),
1703 });
1704 assert!(
1705 probe_legacy_mint_links(&baseline, &entries)
1706 .unwrap()
1707 .is_empty()
1708 );
1709 let result = migrate_legacy_prefix(&baseline, &entries).unwrap();
1710 assert_eq!(
1711 statement_ids(&result.graph.to_snapshot().edges),
1712 BTreeSet::from(["surface-carried".into()])
1713 );
1714 assert!(statement_ids(&result.graph.to_snapshot().resource_edges).is_empty());
1715 }
1716 }
1717
1718 #[test]
1719 fn legacy_resource_migration_new_carried_conflicted_placement_refuses_with_known_handle_controls()
1720 {
1721 let baseline = baseline(&["https://a.test/old", "https://b.test/"]);
1722 let predicate = "https://vocab.test/conflicted";
1723 let author = Author::person("mint");
1724 let mut declarations = Graph::new();
1725 let resource_choice = declarations
1726 .declare_predicate(predicate, GraphStratum::Resource)
1727 .unwrap();
1728 let surface_choice = declarations
1729 .declare_predicate(predicate, GraphStratum::Surface)
1730 .unwrap();
1731 let resource_id = ResourceNode::for_term(predicate).id();
1732 let mut conflict = declarations.resource_record(resource_id).unwrap();
1733 let facet = conflict
1734 .facets
1735 .iter_mut()
1736 .find(|facet| facet.facet == PREDICATE_DECLARATIONS_FACET)
1737 .unwrap();
1738 let mut choices: super::super::PredicateDeclarations =
1739 serde_json::from_str(&facet.value_json).unwrap();
1740 choices.selected = None;
1741 facet.value_json = serde_json::to_string(&choices).unwrap();
1742 let mut journal = GraphJournal::new();
1743 journal.record_as(
1744 author.clone(),
1745 CapturedDelta::ReplayAssertSemanticPredicateByIds {
1746 from_id: Uuid::from_u128(1).to_string(),
1747 to_id: Uuid::from_u128(2).to_string(),
1748 predicate: predicate.into(),
1749 },
1750 );
1751 journal.record(CapturedDelta::ReplaySetNodeUrlById {
1752 node_id: Uuid::from_u128(1).to_string(),
1753 new_url: "https://a.test/new".into(),
1754 });
1755 journal.record(CapturedDelta::ReplaySetResourceRecordById {
1756 resource_id: resource_id.to_string(),
1757 record: Some(conflict.clone()),
1758 });
1759 let mut carried = payload("new-carried", predicate, Some(&author.asserter_iri()));
1760 carried.assertions.statements[0].graph_scope = GraphScope::Default;
1761 journal.record(exact(1, 2, &carried));
1762 let before = serde_json::to_vec(journal.entries()).unwrap();
1763 let error = migrate_legacy_prefix(&baseline, journal.entries())
1764 .err()
1765 .unwrap();
1766 assert!(error.to_string().contains("checkpoint C22"));
1767 let mut checkpoint = baseline.clone();
1768 let revision = checkpoint.revision();
1769 assert!(
1770 journal
1771 .migrated_replay_from_with_baseline(Seq(0), &mut checkpoint, &baseline)
1772 .is_err()
1773 );
1774 assert_eq!(checkpoint.to_snapshot().edges, baseline.to_snapshot().edges);
1775 assert_eq!(checkpoint.revision(), revision);
1776 assert_eq!(serde_json::to_vec(journal.entries()).unwrap(), before);
1777 for (selected, stratum) in [
1778 (resource_choice, GraphStratum::Resource),
1779 (surface_choice, GraphStratum::Surface),
1780 ] {
1781 choices.selected = Some(selected);
1782 let mut record = conflict.clone();
1783 record
1784 .facets
1785 .iter_mut()
1786 .find(|facet| facet.facet == PREDICATE_DECLARATIONS_FACET)
1787 .unwrap()
1788 .value_json = serde_json::to_string(&choices).unwrap();
1789 let mut entries = journal.entries().to_vec();
1790 entries[2].delta = CapturedDelta::ReplaySetResourceRecordById {
1791 resource_id: resource_id.to_string(),
1792 record: Some(record),
1793 };
1794 let diagnostics = probe_legacy_mint_links(&baseline, &entries).unwrap();
1795 let resolutions = if stratum == GraphStratum::Resource {
1796 assert_eq!(diagnostics.len(), 1);
1797 vec![LegacyResourceOriginResolution {
1798 statement_id: "new-carried".into(),
1799 from_resource_id: parse_id(&diagnostics[0].earlier_resource_pair.0).unwrap(),
1800 to_resource_id: parse_id(&diagnostics[0].earlier_resource_pair.1).unwrap(),
1801 }]
1802 } else {
1803 assert!(diagnostics.is_empty());
1804 vec![]
1805 };
1806 let result =
1807 migrate_legacy_prefix_with_resolutions(&baseline, &entries, &resolutions).unwrap();
1808 assert_eq!(
1809 statement_ids(&result.graph.to_snapshot().resource_edges).contains("new-carried"),
1810 stratum == GraphStratum::Resource
1811 );
1812 assert_eq!(
1813 statement_ids(&result.graph.to_snapshot().edges).contains("new-carried"),
1814 stratum == GraphStratum::Surface
1815 );
1816 }
1817 let mut known = GraphJournal::new();
1819 known.record(exact(1, 2, &carried));
1820 known.record(CapturedDelta::ReplaySetResourceRecordById {
1821 resource_id: resource_id.to_string(),
1822 record: Some(conflict),
1823 });
1824 known.record(exact(1, 2, &carried));
1825 let result = migrate_legacy_prefix(&baseline, known.entries()).unwrap();
1826 assert_eq!(
1827 statement_ids(&result.graph.to_snapshot().resource_edges),
1828 BTreeSet::from(["new-carried".into()])
1829 );
1830 assert!(result.graph.effective_predicate_stratum(predicate).is_err());
1831 }
1832
1833 #[test]
1834 fn legacy_resource_migration_canonical_family_records_keep_exact_ids_without_aggregate_copies()
1835 {
1836 let baseline = baseline(&["https://a.test/old", "https://b.test/"]);
1837 let kinds: Vec<_> = [(2u32, 7), (4, 7), (5, 9)]
1838 .into_iter()
1839 .flat_map(|(family, count)| (0..count).map(move |sub| (family << 24) | sub))
1840 .map(|tag| super::super::RelationKind::from_tag(tag).unwrap())
1841 .collect();
1842 assert_eq!(kinds.len(), 23);
1843 let mut all = EdgePayload::new();
1844 for kind in &kinds {
1845 all.assert_relation(aggregate_assertion(*kind));
1846 }
1847 let exact_ids: BTreeSet<_> = all
1848 .assertions()
1849 .iter()
1850 .map(|statement| statement.statement_id.clone())
1851 .collect();
1852 let mut journal = GraphJournal::new();
1853 journal.record_as(
1854 Author::engine("legacy-import", "v7").via("reader"),
1855 exact(1, 2, &all),
1856 );
1857 let result = migrate_legacy_prefix(&baseline, journal.entries()).unwrap();
1858 let snapshot = result.graph.to_snapshot();
1859 let resource_tags = persisted_aggregate_tags(&snapshot.resource_edges);
1863 let surface_tags = persisted_aggregate_tags(&snapshot.edges);
1864 assert!(resource_tags.is_empty());
1865 assert!(surface_tags.is_empty());
1866 let resource_ids = statement_ids(&snapshot.resource_edges);
1867 let surface_ids = statement_ids(&snapshot.edges);
1868 assert_eq!(resource_ids.len(), 16);
1869 assert_eq!(surface_ids.len(), 7);
1870 assert_eq!(
1871 resource_ids
1872 .union(&surface_ids)
1873 .cloned()
1874 .collect::<BTreeSet<_>>(),
1875 exact_ids
1876 );
1877 for edge in &snapshot.resource_edges {
1878 for statement in payload_from_persisted(edge).assertions() {
1879 assert_eq!(
1880 super::super::built_in_relation_stratum(statement.relation_kind()),
1881 GraphStratum::Resource
1882 );
1883 }
1884 }
1885 for edge in &snapshot.edges {
1886 for statement in payload_from_persisted(edge).assertions() {
1887 assert_eq!(
1888 super::super::built_in_relation_stratum(statement.relation_kind()),
1889 GraphStratum::Surface
1890 );
1891 }
1892 }
1893 let from = ResourceNode::new("https://a.test/old").id();
1894 let record = result.graph.resource_record(from).unwrap();
1895 assert!(
1896 !record
1897 .facets
1898 .iter()
1899 .any(|facet| facet.facet == LEGACY_AGGREGATE_MIGRATION_FACET)
1900 );
1901 let mut effective = baseline.clone();
1902 replay_captured_deltas_onto(&mut effective, result.baseline_effects);
1903 for effects in result.entry_effects {
1904 replay_captured_deltas_onto(&mut effective, effects);
1905 }
1906 assert_eq!(
1907 effective.to_snapshot().resource_edges,
1908 result.graph.to_snapshot().resource_edges
1909 );
1910 assert_eq!(
1911 effective.to_snapshot().edges,
1912 result.graph.to_snapshot().edges
1913 );
1914 }
1915
1916 #[test]
1917 fn legacy_resource_migration_aggregate_original_pair_survives_withdrawal_and_typed_takeover() {
1918 let baseline = baseline(&[
1919 "https://a.test/old",
1920 "https://a.test/old",
1921 "https://b.test/",
1922 ]);
1923 let mut claim = EdgePayload::new();
1924 claim.assert_relation(EdgeAssertion::Provenance {
1925 sub_kind: ProvenanceSubKind::ClippedFrom,
1926 });
1927 let legacy_kind = super::super::RelationKind::Provenance(ProvenanceSubKind::ClippedFrom);
1928 let mint = Author::person("mint");
1929 let mut journal = GraphJournal::new();
1930 journal.record_as(mint, exact_legacy(1, 3, legacy_kind));
1931 journal.record_as(Author::person("alias"), exact_legacy(2, 3, legacy_kind));
1932 journal.record(CapturedDelta::ReplaySetNodeUrlById {
1933 node_id: Uuid::from_u128(1).to_string(),
1934 new_url: "https://a.test/new".into(),
1935 });
1936 journal.record(clear(1, 3));
1937 let pair = resource_pair("https://a.test/old", "https://b.test/");
1938 let withdrawn = migrate_legacy_prefix(&baseline, journal.entries()).unwrap();
1939 assert_eq!(
1940 persisted_aggregate_tags(
1941 &withdrawn
1942 .graph
1943 .persisted_resource_edges_between(pair.0, pair.1)
1944 )
1945 .len(),
1946 1,
1947 "withdrawal preserves the other original surface pair"
1948 );
1949 journal.record_as(Author::person("restorer"), exact_legacy(1, 3, legacy_kind));
1953 let restored = migrate_legacy_prefix(&baseline, journal.entries()).unwrap();
1954 assert_eq!(
1955 persisted_aggregate_tags(
1956 &restored
1957 .graph
1958 .persisted_resource_edges_between(pair.0, pair.1)
1959 )
1960 .len(),
1961 2
1962 );
1963 assert!(
1964 restored
1965 .graph
1966 .persisted_resource_edges_between(
1967 ResourceNode::new("https://a.test/new").id(),
1968 pair.1
1969 )
1970 .is_empty()
1971 );
1972 let notes: Vec<LegacyAggregateMigrationNote> = serde_json::from_str(
1973 &restored
1974 .graph
1975 .resource_record(pair.0)
1976 .unwrap()
1977 .facets
1978 .iter()
1979 .find(|facet| facet.facet == LEGACY_AGGREGATE_MIGRATION_FACET)
1980 .unwrap()
1981 .value_json,
1982 )
1983 .unwrap();
1984 assert_eq!(notes.len(), 2);
1985 assert_eq!(
1986 notes
1987 .iter()
1988 .find(|note| note.from_surface_id == Uuid::from_u128(1).to_string())
1989 .unwrap()
1990 .author,
1991 None,
1992 "an aggregate snapshot has no exact mint event author"
1993 );
1994 let typed = vec![persisted_edge_for_ids(pair.0, pair.1, &claim)];
1995 journal.record(CapturedDelta::ReplaySetResourceEdgesByIds {
1996 from_resource_id: pair.0.to_string(),
1997 to_resource_id: pair.1.to_string(),
1998 edges: typed.clone(),
1999 });
2000 journal.record(CapturedDelta::ReplaySetNodeTitleById {
2001 node_id: Uuid::from_u128(2).to_string(),
2002 title: "unrelated".into(),
2003 });
2004 let taken = migrate_legacy_prefix(&baseline, journal.entries()).unwrap();
2005 assert_eq!(
2006 taken.graph.persisted_resource_edges_between(pair.0, pair.1),
2007 typed,
2008 "explicit pair ownership is not repopulated by an unrelated edit"
2009 );
2010 journal.record(clear(1, 3));
2011 journal.record(exact_legacy(1, 3, legacy_kind));
2012 let new_member = migrate_legacy_prefix(&baseline, journal.entries()).unwrap();
2013 let new_member_edges = new_member
2014 .graph
2015 .persisted_resource_edges_between(pair.0, pair.1);
2016 assert_eq!(persisted_aggregate_tags(&new_member_edges).len(), 1);
2017 let records: Vec<_> = new_member_edges
2018 .iter()
2019 .flat_map(|edge| edge.retained_assertions())
2020 .collect();
2021 assert_eq!(
2022 records.len(),
2023 2,
2024 "a later legacy reappearance adds its own copy without erasing the typed copy"
2025 );
2026 assert!(
2027 records.contains(&&typed[0].retained_assertions()[0]),
2028 "the explicit typed record remains exact alongside the legacy copy"
2029 );
2030 journal.record(clear(1, 3));
2031 let final_state = migrate_legacy_prefix(&baseline, journal.entries()).unwrap();
2032 assert_eq!(
2033 final_state
2034 .graph
2035 .persisted_resource_edges_between(pair.0, pair.1),
2036 typed
2037 );
2038 }
2039
2040 #[test]
2041 fn legacy_resource_migration_preserves_baseline_handles_and_uncertainty_with_surface_controls()
2042 {
2043 let mut baseline = baseline(&["https://a.test/current", "https://b.test/current"]);
2044 let mut held = payload("unknown", predicate_iri(SemanticSubKind::Cites), None);
2045 held.push_persisted_semantic_statement(SemanticStatement {
2046 statement_id: "group".into(),
2047 predicate: predicate_iri(SemanticSubKind::UserGrouped).into(),
2048 recognized_sub_kind: Some(SemanticSubKind::UserGrouped),
2049 label: Some("surface control".into()),
2050 graph_scope: GraphScope::User,
2051 provenance_iri: Some("https://group-author.test/".into()),
2052 asserted_at_ms: Some(9),
2053 first_asserted_ms: Some(9),
2054 withdrawn: None,
2055 basis: Default::default(),
2056 });
2057 held.assert_relation(EdgeAssertion::Imported {
2058 sub_kind: ImportedSubKind::BookmarkFolder,
2059 });
2060 held.assert_relation(EdgeAssertion::Provenance {
2061 sub_kind: ProvenanceSubKind::ClippedFrom,
2062 });
2063 let a = baseline.get_node_key_by_id(Uuid::from_u128(1)).unwrap();
2064 let b = baseline.get_node_key_by_id(Uuid::from_u128(2)).unwrap();
2065 baseline.inner.connect(a, b, held.clone());
2066 let before = baseline.to_snapshot();
2067 let replay = migrate_legacy_prefix(&baseline, &[]).unwrap();
2068 assert_eq!(
2069 baseline.to_snapshot().edges,
2070 before.edges,
2071 "input remains exact"
2072 );
2073 let pair = resource_pair("https://a.test/current", "https://b.test/current");
2074 let claims = replay
2075 .graph
2076 .persisted_resource_edges_between(pair.0, pair.1);
2077 let source_payload = payload_from_persisted(&before.edges[0]);
2078 let expected_resource_ids: BTreeSet<_> = source_payload
2079 .assertions()
2080 .iter()
2081 .filter(|statement| {
2082 historical_statement_stratum(&baseline, statement) == GraphStratum::Resource
2083 })
2084 .map(|statement| statement.statement_id.clone())
2085 .collect();
2086 let expected_surface_ids: BTreeSet<_> = source_payload
2087 .assertions()
2088 .iter()
2089 .filter(|statement| {
2090 historical_statement_stratum(&baseline, statement) == GraphStratum::Surface
2091 })
2092 .map(|statement| statement.statement_id.clone())
2093 .collect();
2094 assert_eq!(statement_ids(&claims), expected_resource_ids);
2095 assert!(statement_ids(&claims).contains("unknown"));
2096 let claim = claims
2097 .iter()
2098 .flat_map(|edge| edge.retained_assertions())
2099 .find(|statement| statement.statement_id == "unknown")
2100 .expect("unknown legacy statement remains available");
2101 assert_eq!(claim.asserted_at_ms, Some(100));
2102 assert_eq!(
2103 claim.provenance_iri.as_deref(),
2104 Some(super::super::edge_data::UNKNOWN_LEGACY_ASSERTER_IRI)
2105 );
2106 let held_surface = replay.graph.persisted_edges_between(a, b);
2107 assert_eq!(
2108 statement_ids(&held_surface),
2109 expected_surface_ids,
2110 "canonical surface-family records remain on the original Surface pair"
2111 );
2112 assert_eq!(held_surface[0].imported, before.edges[0].imported);
2113 assert!(held_surface[0].provenance.is_none());
2114 assert!(
2115 claims
2116 .iter()
2117 .any(|edge| edge.provenance == before.edges[0].provenance)
2118 );
2119 assert_eq!(
2120 held_surface[0]
2121 .retained_assertions()
2122 .iter()
2123 .find(|statement| statement.statement_id == "group")
2124 .expect("the held user-grouped claim remains on Surface")
2125 .provenance_iri
2126 .as_deref(),
2127 Some("https://group-author.test/")
2128 );
2129 let record = replay.graph.resource_record(pair.0).unwrap();
2130 let notes: Vec<LegacyMigrationNote> = serde_json::from_str(
2131 &record
2132 .facets
2133 .iter()
2134 .find(|facet| facet.facet == LEGACY_RESOURCE_MIGRATION_FACET)
2135 .unwrap()
2136 .value_json,
2137 )
2138 .unwrap();
2139 assert_eq!(notes.len(), expected_resource_ids.len());
2140 let claim_note = notes
2141 .iter()
2142 .find(|note| note.statement.statement_id == claim.statement_id)
2143 .expect("each exact carried record keeps its own migration note");
2144 assert_eq!(claim_note.from_surface_id, Uuid::from_u128(1).to_string());
2145 assert_eq!(claim_note.to_surface_id, Uuid::from_u128(2).to_string());
2146 assert_eq!(
2147 claim_note.uncertainty,
2148 "baseline_current_resources_without_mint_event"
2149 );
2150 assert_eq!(replay.graph.shown_resource_id(a), Some(pair.0));
2151 let mut effective = baseline.clone();
2152 replay_captured_deltas_onto(&mut effective, replay.baseline_effects);
2153 assert_eq!(
2154 effective.to_snapshot().resource_edges,
2155 replay.graph.to_snapshot().resource_edges
2156 );
2157 assert_eq!(
2158 effective.to_snapshot().edges,
2159 replay.graph.to_snapshot().edges
2160 );
2161 assert!(
2162 !record
2163 .facets
2164 .iter()
2165 .any(|facet| facet.facet == LEGACY_AGGREGATE_MIGRATION_FACET)
2166 );
2167 let mut noted_baseline = baseline.clone();
2168 for record in &replay.graph.to_snapshot().resources {
2169 assert!(noted_baseline.set_resource_record(
2170 ResourceNode::for_term(&record.canonical_iri).id(),
2171 Some(record.clone())
2172 ));
2173 }
2174 let repeated = migrate_legacy_prefix(¬ed_baseline, &[]).unwrap();
2175 assert_eq!(
2176 repeated.graph.resource_record(pair.0),
2177 replay.graph.resource_record(pair.0),
2178 "an existing identical uncertainty note is a valid no-op"
2179 );
2180 }
2181
2182 #[test]
2183 fn legacy_resource_migration_lifetime_and_pair_membership_survive_navigation_and_restore() {
2184 let baseline = baseline(&[
2185 "https://a.test/old",
2186 "https://a.test/old",
2187 "https://b.test/",
2188 ]);
2189 let alice = Author::person("alice");
2190 let bob = Author::person("bob");
2191 let mut journal = GraphJournal::new();
2192 let predicate = predicate_iri(SemanticSubKind::Cites);
2193 journal.record_as(alice.clone(), exact(1, 3, &payload("one", predicate, None)));
2194 journal.record_as(bob.clone(), exact(2, 3, &payload("two", predicate, None)));
2195 journal.record(CapturedDelta::ReplaySetNodeUrlById {
2196 node_id: Uuid::from_u128(1).to_string(),
2197 new_url: "https://a.test/new".into(),
2198 });
2199 journal.record(clear(1, 3));
2200 let pair = resource_pair("https://a.test/old", "https://b.test/");
2201 let withdrawn = journal
2202 .migrated_prefix_at_from(&baseline, journal.live_cursor())
2203 .unwrap()
2204 .unwrap();
2205 assert_eq!(
2206 statement_ids(
2207 &withdrawn
2208 .graph
2209 .persisted_resource_edges_between(pair.0, pair.1)
2210 ),
2211 BTreeSet::from(["two".into()]),
2212 "other original surface pair survives withdrawal"
2213 );
2214 let checkpoint_cursor = journal.live_cursor();
2215 let mut checkpoint = journal
2216 .snapshot_at_from(&baseline, checkpoint_cursor)
2217 .unwrap()
2218 .unwrap();
2219 journal.record_as(
2220 Author::person("restorer"),
2221 exact(1, 3, &payload("one", predicate, None)),
2222 );
2223 let replay = journal
2224 .migrated_prefix_at_from(&baseline, journal.live_cursor())
2225 .unwrap()
2226 .unwrap();
2227 let claims = replay
2228 .graph
2229 .persisted_resource_edges_between(pair.0, pair.1);
2230 assert_eq!(
2231 statement_ids(&claims),
2232 BTreeSet::from(["one".into(), "two".into()])
2233 );
2234 for (id, author) in [("one", alice), ("two", bob)] {
2235 let statement = claims
2236 .iter()
2237 .flat_map(|edge| edge.retained_assertions())
2238 .find(|statement| statement.statement_id == id)
2239 .unwrap();
2240 assert_eq!(statement.asserted_at_ms, Some(100));
2241 assert_eq!(statement.provenance_iri, Some(author.asserter_iri()));
2242 }
2243 let new = ResourceNode::new("https://a.test/new").id();
2244 assert!(
2245 replay
2246 .graph
2247 .persisted_resource_edges_between(new, pair.1)
2248 .is_empty(),
2249 "restored handle does not follow navigation"
2250 );
2251 assert_eq!(
2252 replay
2253 .graph
2254 .shown_resource_id(replay.graph.get_node_key_by_id(Uuid::from_u128(1)).unwrap()),
2255 Some(new)
2256 );
2257 assert!(
2258 replay
2259 .graph
2260 .to_snapshot()
2261 .edges
2262 .iter()
2263 .all(|edge| edge.semantic.is_none() && edge.assertions.is_some())
2264 );
2265 journal
2266 .migrated_replay_from_with_baseline(checkpoint_cursor, &mut checkpoint, &baseline)
2267 .unwrap();
2268 assert_eq!(
2269 checkpoint.to_snapshot().resource_edges,
2270 replay.graph.to_snapshot().resource_edges
2271 );
2272 let mut effective = baseline.clone();
2273 replay_captured_deltas_onto(
2274 &mut effective,
2275 replay
2276 .baseline_effects
2277 .into_iter()
2278 .chain(replay.entry_effects.into_iter().flatten()),
2279 );
2280 assert_eq!(
2281 effective.to_snapshot().resource_edges,
2282 replay.graph.to_snapshot().resource_edges
2283 );
2284 assert!(
2285 journal
2286 .migrated_snapshot_at_from(&baseline, Seq(journal.live_cursor().0 + 1))
2287 .unwrap()
2288 .is_none()
2289 );
2290 }
2291
2292 #[test]
2293 fn legacy_resource_migration_typed_pair_owns_only_its_pair_and_is_not_repopulated() {
2294 let baseline = baseline(&[
2295 "https://a.test/",
2296 "https://b.test/",
2297 "https://c.test/",
2298 "https://d.test/",
2299 ]);
2300 let mut journal = GraphJournal::new();
2301 let predicate = predicate_iri(SemanticSubKind::Cites);
2302 journal.record(exact(
2303 1,
2304 2,
2305 &payload("old-a", predicate, Some("https://author.test/")),
2306 ));
2307 journal.record(exact(
2308 3,
2309 4,
2310 &payload("old-c", predicate, Some("https://author.test/")),
2311 ));
2312 let first = resource_pair("https://a.test/", "https://b.test/");
2313 let second = resource_pair("https://c.test/", "https://d.test/");
2314 let typed = persisted_edge_for_ids(
2315 first.0,
2316 first.1,
2317 &payload("typed", predicate, Some("https://typed-author.test/")),
2318 );
2319 journal.record(CapturedDelta::ReplaySetResourceEdgesByIds {
2320 from_resource_id: first.0.to_string(),
2321 to_resource_id: first.1.to_string(),
2322 edges: vec![typed.clone()],
2323 });
2324 let mut update = payload("old-c", predicate, Some("https://author.test/"));
2325 update.assertions.statements[0].label = Some("later unrelated edit".into());
2326 journal.record(exact(3, 4, &update));
2327 let replay = journal
2328 .migrated_prefix_at_from(&baseline, journal.live_cursor())
2329 .unwrap()
2330 .unwrap();
2331 assert_eq!(
2332 replay
2333 .graph
2334 .persisted_resource_edges_between(first.0, first.1),
2335 vec![typed]
2336 );
2337 assert_eq!(
2338 statement_ids(
2339 &replay
2340 .graph
2341 .persisted_resource_edges_between(second.0, second.1)
2342 ),
2343 BTreeSet::from(["old-c".into()])
2344 );
2345 assert!(
2346 replay
2347 .graph
2348 .to_snapshot()
2349 .edges
2350 .iter()
2351 .all(|edge| edge.semantic.is_none() && edge.assertions.is_some())
2352 );
2353 journal.record(CapturedDelta::ReplaySetResourceEdgesByIds {
2354 from_resource_id: first.0.to_string(),
2355 to_resource_id: first.1.to_string(),
2356 edges: vec![],
2357 });
2358 journal.record(exact(3, 4, &update));
2359 let cleared = journal
2360 .migrated_snapshot_at_from(&baseline, journal.live_cursor())
2361 .unwrap()
2362 .unwrap();
2363 assert!(
2364 cleared
2365 .persisted_resource_edges_between(first.0, first.1)
2366 .is_empty(),
2367 "unrelated old membership cannot undo explicit typed clear"
2368 );
2369 assert_eq!(
2370 statement_ids(&cleared.persisted_resource_edges_between(second.0, second.1)),
2371 BTreeSet::from(["old-c".into()])
2372 );
2373 }
2374
2375 #[test]
2376 fn legacy_resource_migration_authored_overrides_apply_at_mint_and_conflicts_keep_typed_history()
2377 {
2378 let baseline = baseline(&["https://a.test/", "https://b.test/"]);
2379 let predicate = "https://vocab.test/p#custom";
2380 let mut declarations = Graph::new();
2381 declarations
2382 .declare_predicate(predicate, GraphStratum::Surface)
2383 .unwrap();
2384 let id = ResourceNode::for_term(predicate).id();
2385 let surface = declarations.resource_record(id).unwrap();
2386 declarations
2387 .declare_predicate(predicate, GraphStratum::Resource)
2388 .unwrap();
2389 let resource = declarations.resource_record(id).unwrap();
2390 let mut journal = GraphJournal::new();
2391 journal.record(CapturedDelta::ReplaySetResourceRecordById {
2392 resource_id: id.to_string(),
2393 record: Some(surface),
2394 });
2395 journal.record(exact(
2396 1,
2397 2,
2398 &payload("surface-mint", predicate, Some("https://author.test/")),
2399 ));
2400 journal.record(CapturedDelta::ReplaySetResourceRecordById {
2401 resource_id: id.to_string(),
2402 record: Some(resource),
2403 });
2404 let mut both = payload("surface-mint", predicate, Some("https://author.test/"));
2405 both.push_persisted_semantic_statement(SemanticStatement {
2406 statement_id: "resource-mint".into(),
2407 predicate: predicate.into(),
2408 recognized_sub_kind: None,
2409 label: None,
2410 graph_scope: GraphScope::User,
2411 provenance_iri: Some("https://other.test/".into()),
2412 asserted_at_ms: Some(200),
2413 first_asserted_ms: Some(200),
2414 withdrawn: None,
2415 basis: Default::default(),
2416 });
2417 journal.record(exact(1, 2, &both));
2418 let migrated = journal
2419 .migrated_snapshot_at_from(&baseline, journal.live_cursor())
2420 .unwrap()
2421 .unwrap();
2422 assert_eq!(
2423 statement_ids(&migrated.to_snapshot().edges),
2424 BTreeSet::from(["surface-mint".into()])
2425 );
2426 assert_eq!(
2427 statement_ids(&migrated.to_snapshot().resource_edges),
2428 BTreeSet::from(["resource-mint".into()])
2429 );
2430 let mut conflicted = migrated.clone();
2431 let mut record = conflicted.resource_record(id).unwrap();
2432 let facet = record
2433 .facets
2434 .iter_mut()
2435 .find(|facet| facet.facet == PREDICATE_DECLARATIONS_FACET)
2436 .unwrap();
2437 let mut declarations: super::super::PredicateDeclarations =
2438 serde_json::from_str(&facet.value_json).unwrap();
2439 declarations.selected = None;
2440 facet.value_json = serde_json::to_string(&declarations).unwrap();
2441 assert!(conflicted.set_resource_record(id, Some(record)));
2442 assert!(conflicted.effective_predicate_stratum(predicate).is_err());
2443 let mut typed_only = baseline.clone();
2445 for record in &conflicted.to_snapshot().resources {
2446 let resource = ResourceNode::for_term(&record.canonical_iri).id();
2447 typed_only.set_resource_record(resource, Some(record.clone()));
2448 }
2449 let pair = resource_pair("https://a.test/", "https://b.test/");
2450 let typed = conflicted.persisted_resource_edges_between(pair.0, pair.1);
2451 assert!(typed_only.set_resource_edges_between(pair.0, pair.1, &typed));
2452 let replay = migrate_legacy_prefix(&typed_only, &[]).unwrap();
2453 assert_eq!(
2454 replay
2455 .graph
2456 .persisted_resource_edges_between(pair.0, pair.1),
2457 typed
2458 );
2459 assert!(replay.graph.effective_predicate_stratum(predicate).is_err());
2460 }
2461
2462 #[test]
2463 fn legacy_resource_migration_handle_collision_is_atomic_with_distinct_handle_control() {
2464 let mut baseline = baseline(&["https://a.test/", "https://b.test/"]);
2465 let a = baseline.get_node_key_by_id(Uuid::from_u128(1)).unwrap();
2466 let b = baseline.get_node_key_by_id(Uuid::from_u128(2)).unwrap();
2467 let predicate = predicate_iri(SemanticSubKind::Cites);
2468 baseline.inner.connect(
2469 a,
2470 b,
2471 payload("collision", predicate, Some("https://legacy.test/")),
2472 );
2473 let resources = [
2474 ResourceNode::for_term("https://other.test/a"),
2475 ResourceNode::for_term("https://other.test/b"),
2476 ];
2477 for resource in &resources {
2478 assert!(baseline.set_resource_record(
2479 resource.id(),
2480 Some(PersistedResourceRecord {
2481 canonical_iri: resource.canonical_iri().into(),
2482 facets: vec![]
2483 })
2484 ));
2485 }
2486 let pair = (resources[0].id(), resources[1].id());
2487 let from = baseline.resources.key_of(&pair.0).unwrap();
2489 let to = baseline.resources.key_of(&pair.1).unwrap();
2490 baseline.resources.connect(
2491 from,
2492 to,
2493 payload("collision", predicate, Some("https://typed.test/")),
2494 );
2495 let before = baseline.to_snapshot();
2496 assert!(migrate_legacy_prefix(&baseline, &[]).is_err());
2497 assert_eq!(baseline.to_snapshot().edges, before.edges);
2498 assert_eq!(baseline.to_snapshot().resource_edges, before.resource_edges);
2499 let keys: Vec<_> = baseline.resources.inner().edge_indices().collect();
2500 for key in keys {
2501 baseline.resources.disconnect(key);
2502 }
2503 assert!(baseline.set_resource_edges_between(
2504 pair.0,
2505 pair.1,
2506 &[persisted_edge_for_ids(
2507 pair.0,
2508 pair.1,
2509 &payload("distinct", predicate, Some("https://typed.test/"))
2510 )]
2511 ));
2512 let valid = migrate_legacy_prefix(&baseline, &[]).unwrap();
2513 assert_eq!(
2514 statement_ids(&valid.graph.to_snapshot().resource_edges),
2515 BTreeSet::from(["collision".into(), "distinct".into()])
2516 );
2517 }
2518
2519 #[test]
2520 fn legacy_resource_migration_claim_identity_survives_absence_and_allows_metadata_updates() {
2521 let baseline = baseline(&["https://a.test/", "https://b.test/"]);
2522 let predicate = predicate_iri(SemanticSubKind::Cites);
2523 let held = payload("held", predicate, Some("https://author.test/"));
2524 let mut journal = GraphJournal::new();
2525 journal.record(exact(1, 2, &held));
2526 journal.record(clear(1, 2));
2527 let mut metadata = held.clone();
2528 let statement = &mut metadata.assertions.statements[0];
2529 statement.label = Some("new label".into());
2530 statement.basis.note = Some("new label".into());
2531 statement.asserted_at_ms = Some(300);
2532 journal.record(exact(1, 2, &metadata));
2533 let valid = journal
2534 .migrated_snapshot_at_from(&baseline, journal.live_cursor())
2535 .unwrap()
2536 .unwrap();
2537 let valid_snapshot = valid.to_snapshot();
2538 let statement = &valid_snapshot.resource_edges[0].retained_assertions()[0];
2539 assert_eq!(statement.statement_id, "held");
2540 assert_eq!(statement.label.as_deref(), Some("new label"));
2541 assert_eq!(statement.asserted_at_ms, Some(300));
2542 for change in 0..4 {
2543 let mut conflict = held.clone();
2544 let statement = &mut conflict.assertions.statements[0];
2545 match change {
2546 0 => statement.predicate = "https://vocab.test/changed".into(),
2547 1 => statement.recognized_sub_kind = Some(SemanticSubKind::Quotes),
2548 2 => statement.graph_scope = GraphScope::Default,
2549 _ => statement.provenance_iri = Some("https://changed-author.test/".into()),
2550 }
2551 let mut divergent = journal.clone();
2552 divergent.record(clear(1, 2));
2553 divergent.record(exact(1, 2, &conflict));
2554 let source_before = serde_json::to_vec(divergent.entries()).unwrap();
2555 let mut checkpoint = valid.clone();
2556 let before = checkpoint.to_snapshot();
2557 assert!(
2558 divergent
2559 .migrated_replay_from_with_baseline(Seq(0), &mut checkpoint, &baseline)
2560 .is_err()
2561 );
2562 assert_eq!(
2563 checkpoint.to_snapshot().resource_edges,
2564 before.resource_edges
2565 );
2566 assert_eq!(
2567 serde_json::to_vec(divergent.entries()).unwrap(),
2568 source_before
2569 );
2570 conflict.assertions.statements[0].statement_id = format!("distinct-{change}");
2571 let mut distinct = journal.clone();
2572 distinct.record(exact(1, 2, &conflict));
2573 assert!(
2574 distinct
2575 .migrated_snapshot_at_from(&baseline, distinct.live_cursor())
2576 .unwrap()
2577 .is_some(),
2578 "distinct-handle control"
2579 );
2580 }
2581 }
2582
2583 #[test]
2584 fn legacy_resource_migration_dedupes_identical_parallel_handle_copies_and_says_so() {
2585 let mut baseline = baseline(&["https://a.test/", "https://b.test/"]);
2586 let a = baseline.get_node_key_by_id(Uuid::from_u128(1)).unwrap();
2587 let b = baseline.get_node_key_by_id(Uuid::from_u128(2)).unwrap();
2588 let claim = payload(
2589 "copied",
2590 predicate_iri(SemanticSubKind::Cites),
2591 Some("https://author.test/"),
2592 );
2593 baseline.inner.connect(a, b, claim.clone());
2594 baseline.inner.connect(a, b, claim);
2595 let migrated = migrate_legacy_prefix(&baseline, &[]).unwrap();
2596 let pair = resource_pair("https://a.test/", "https://b.test/");
2597 let rows = migrated
2598 .graph
2599 .persisted_resource_edges_between(pair.0, pair.1);
2600 assert_eq!(rows.len(), 1, "the copy is dropped, the first row kept");
2601 assert_eq!(statement_ids(&rows), BTreeSet::from(["copied".into()]));
2602 assert!(migrated.graph.persisted_edges_between(a, b).is_empty());
2603 let record = migrated.graph.resource_record(pair.0).unwrap();
2604 let notes: Vec<LegacyMigrationNote> = serde_json::from_str(
2605 &record
2606 .facets
2607 .iter()
2608 .find(|facet| facet.facet == LEGACY_RESOURCE_MIGRATION_FACET)
2609 .unwrap()
2610 .value_json,
2611 )
2612 .unwrap();
2613 assert!(
2614 notes
2615 .iter()
2616 .any(|note| note.uncertainty == copies::DEDUPED_COPY
2617 && note.statement.statement_id == "copied")
2618 );
2619 Graph::try_from_snapshot(&migrated.graph.to_snapshot())
2620 .expect("the migrated graph is legal state");
2621 let mut replayed = baseline.clone();
2622 replay_captured_deltas_onto(&mut replayed, migrated.baseline_effects.clone());
2623 assert_eq!(
2624 replayed.to_snapshot().resources,
2625 migrated.graph.to_snapshot().resources
2626 );
2627 assert_eq!(
2628 replayed.to_snapshot().resource_edges,
2629 migrated.graph.to_snapshot().resource_edges
2630 );
2631 let mut invalid = baseline.clone();
2632 let key = invalid.find_edge_key(a, b).unwrap();
2633 invalid.get_edge_mut(key).unwrap().assertions.statements[0].label =
2634 Some("conflicting copy".into());
2635 invalid.get_edge_mut(key).unwrap().assertions.statements[0]
2636 .basis
2637 .note = Some("conflicting copy".into());
2638 assert!(migrate_legacy_prefix(&invalid, &[]).is_err());
2639 assert_eq!(baseline.persisted_edges_between(a, b).len(), 2);
2640 }
2641
2642 #[test]
2643 fn legacy_resource_migration_new_handles_honor_selected_baseline_declarations() {
2644 let mut baseline = baseline(&["https://a.test/", "https://b.test/"]);
2645 let surface_predicate = "https://vocab.test/surface";
2646 baseline
2647 .declare_predicate(surface_predicate, GraphStratum::Surface)
2648 .unwrap();
2649 let mut journal = GraphJournal::new();
2650 journal.record(exact(
2651 1,
2652 2,
2653 &payload(
2654 "new-surface",
2655 surface_predicate,
2656 Some("https://author.test/"),
2657 ),
2658 ));
2659 let mut combined = payload(
2660 "new-surface",
2661 surface_predicate,
2662 Some("https://author.test/"),
2663 );
2664 combined.push_persisted_semantic_statement(SemanticStatement {
2665 statement_id: "resource-control".into(),
2666 predicate: "https://vocab.test/default".into(),
2667 recognized_sub_kind: None,
2668 label: None,
2669 graph_scope: GraphScope::User,
2670 provenance_iri: Some("https://author.test/".into()),
2671 asserted_at_ms: Some(200),
2672 first_asserted_ms: Some(200),
2673 withdrawn: None,
2674 basis: Default::default(),
2675 });
2676 journal.record(exact(1, 2, &combined));
2677 let graph = journal
2678 .migrated_snapshot_at_from(&baseline, journal.live_cursor())
2679 .unwrap()
2680 .unwrap();
2681 assert_eq!(
2682 statement_ids(&graph.to_snapshot().edges),
2683 BTreeSet::from(["new-surface".into()])
2684 );
2685 assert_eq!(
2686 statement_ids(&graph.to_snapshot().resource_edges),
2687 BTreeSet::from(["resource-control".into()])
2688 );
2689 assert_eq!(
2690 graph.effective_predicate_stratum(surface_predicate),
2691 Ok(GraphStratum::Surface)
2692 );
2693 }
2694
2695 #[test]
2696 fn legacy_resource_migration_effective_captures_undo_claim_after_later_navigation() {
2697 let baseline = baseline(&[
2698 "https://a.test/old",
2699 "https://a.test/old",
2700 "https://b.test/",
2701 ]);
2702 let predicate = predicate_iri(SemanticSubKind::Cites);
2703 let mut journal = GraphJournal::new();
2704 journal.record(exact(
2705 2,
2706 3,
2707 &payload("other", predicate, Some("https://other.test/")),
2708 ));
2709 let before = journal
2710 .migrated_snapshot_at_from(&baseline, journal.live_cursor())
2711 .unwrap()
2712 .unwrap();
2713 journal.record(exact(
2714 1,
2715 3,
2716 &payload("mine", predicate, Some("https://author.test/")),
2717 ));
2718 let after = journal
2719 .migrated_prefix_at_from(&baseline, journal.live_cursor())
2720 .unwrap()
2721 .unwrap();
2722 let change = after.entry_effects.last().unwrap().clone();
2723 assert!(
2724 change
2725 .iter()
2726 .any(|delta| matches!(delta, CapturedDelta::ReplaySetResourceEdgesByIds { .. }))
2727 );
2728 journal.record(CapturedDelta::ReplaySetNodeUrlById {
2729 node_id: Uuid::from_u128(1).to_string(),
2730 new_url: "https://a.test/new".into(),
2731 });
2732 let mut live = journal
2733 .migrated_snapshot_at_from(&baseline, journal.live_cursor())
2734 .unwrap()
2735 .unwrap();
2736 let undo = super::super::revert_change(&change, &before, &after.graph, &live);
2737 assert!(undo.kept.is_empty());
2738 replay_captured_deltas_onto(&mut live, undo.edits);
2739 let pair = resource_pair("https://a.test/old", "https://b.test/");
2740 assert_eq!(
2741 statement_ids(&live.persisted_resource_edges_between(pair.0, pair.1)),
2742 BTreeSet::from(["other".into()])
2743 );
2744 let key = live.get_node_key_by_id(Uuid::from_u128(1)).unwrap();
2745 assert_eq!(
2746 live.get_node(key).unwrap().primary_address().as_url_str(),
2747 "https://a.test/new"
2748 );
2749 assert_eq!(
2750 live.shown_resource_id(key),
2751 Some(ResourceNode::new("https://a.test/new").id())
2752 );
2753 }
2754
2755 #[test]
2756 fn legacy_resource_migration_raw_assertion_retains_author_and_historical_endpoints() {
2757 let baseline = baseline(&["https://a.test/old", "https://b.test/"]);
2758 let mut journal = GraphJournal::new();
2759 let author = Author::person("raw-author");
2760 journal.record_as(
2761 author.clone(),
2762 CapturedDelta::ReplayAssertRelationByIds {
2763 from_id: Uuid::from_u128(1).to_string(),
2764 to_id: Uuid::from_u128(2).to_string(),
2765 assertion: EdgeAssertion::Semantic {
2766 sub_kind: SemanticSubKind::Cites,
2767 label: None,
2768 },
2769 },
2770 );
2771 journal.record(CapturedDelta::ReplaySetNodeUrlById {
2772 node_id: Uuid::from_u128(1).to_string(),
2773 new_url: "https://a.test/new".into(),
2774 });
2775 for _ in 0..2 {
2776 let graph = journal
2777 .migrated_snapshot_at_from(&baseline, journal.live_cursor())
2778 .unwrap()
2779 .unwrap();
2780 let pair = resource_pair("https://a.test/old", "https://b.test/");
2781 let claims = graph.persisted_resource_edges_between(pair.0, pair.1);
2782 assert_eq!(claims.len(), 1);
2783 assert_eq!(
2784 claims[0].retained_assertions()[0].provenance_iri,
2785 Some(author.asserter_iri())
2786 );
2787 assert!(
2788 graph
2789 .persisted_resource_edges_between(
2790 ResourceNode::new("https://a.test/new").id(),
2791 pair.1
2792 )
2793 .is_empty()
2794 );
2795 assert!(
2796 graph
2797 .to_snapshot()
2798 .edges
2799 .iter()
2800 .all(|edge| edge.semantic.is_none() && edge.assertions.is_some())
2801 );
2802 }
2803 assert!(
2806 probe_legacy_mint_links(&baseline, journal.entries())
2807 .unwrap()
2808 .is_empty()
2809 );
2810 }
2811
2812 #[test]
2813 fn legacy_resource_migration_probe_reports_mixed_raw_and_carried_evidence_without_aliasing() {
2814 let baseline = baseline(&["https://a.test/old", "https://b.test/"]);
2815 let mut journal = GraphJournal::new();
2816 let author = Author::person("mint-author");
2817 journal.record_as(
2818 author.clone(),
2819 CapturedDelta::ReplayAssertRelationByIds {
2820 from_id: Uuid::from_u128(1).to_string(),
2821 to_id: Uuid::from_u128(2).to_string(),
2822 assertion: EdgeAssertion::Semantic {
2823 sub_kind: SemanticSubKind::Cites,
2824 label: None,
2825 },
2826 },
2827 );
2828 journal.record(CapturedDelta::ReplaySetNodeUrlById {
2829 node_id: Uuid::from_u128(1).to_string(),
2830 new_url: "https://a.test/new".into(),
2831 });
2832 let mut carried = payload(
2833 "carried",
2834 predicate_iri(SemanticSubKind::Cites),
2835 Some(&author.asserter_iri()),
2836 );
2837 carried.assertions.statements[0].graph_scope = GraphScope::Default;
2838 journal.record_as(Author::person("later-author"), exact(1, 2, &carried));
2839 let source_before = serde_json::to_vec(journal.entries()).unwrap();
2840 let diagnostics = probe_legacy_mint_links(&baseline, journal.entries()).unwrap();
2841 assert_eq!(diagnostics.len(), 1);
2842 let diagnostic = &diagnostics[0];
2843 assert_eq!(
2844 (diagnostic.raw_entry_index, diagnostic.carried_entry_index),
2845 (0, 2)
2846 );
2847 assert_eq!(diagnostic.statement_id, "carried");
2848 assert!(diagnostic.explicit_source_matches);
2849 assert_eq!(
2850 diagnostic.earlier_resource_pair.0,
2851 ResourceNode::new("https://a.test/old").id().to_string()
2852 );
2853 assert_eq!(
2854 diagnostic.current_resource_pair.0,
2855 ResourceNode::new("https://a.test/new").id().to_string()
2856 );
2857 assert_eq!(
2858 serde_json::to_vec(journal.entries()).unwrap(),
2859 source_before
2860 );
2861 for candidate in [
2862 &diagnostic.earlier_resource_pair,
2863 &diagnostic.current_resource_pair,
2864 ] {
2865 let choice = LegacyResourceOriginResolution {
2866 statement_id: "carried".into(),
2867 from_resource_id: parse_id(&candidate.0).unwrap(),
2868 to_resource_id: parse_id(&candidate.1).unwrap(),
2869 };
2870 validate_legacy_origin_resolutions(&baseline, journal.entries(), &[choice.clone()])
2871 .unwrap();
2872 let resolved = migrate_legacy_prefix_with_resolutions(
2873 &baseline,
2874 journal.entries(),
2875 &[choice.clone()],
2876 )
2877 .unwrap();
2878 let exact = resolved
2879 .graph
2880 .persisted_resource_edges_between(choice.from_resource_id, choice.to_resource_id);
2881 assert_eq!(statement_ids(&exact), BTreeSet::from(["carried".into()]));
2882 let claim = &exact
2883 .iter()
2884 .find(|edge| !edge.retained_assertions().is_empty())
2885 .unwrap()
2886 .retained_assertions()[0];
2887 assert_eq!(
2888 claim,
2889 &persisted_edge_for_ids(Uuid::from_u128(1), Uuid::from_u128(2), &carried)
2890 .retained_assertions()[0],
2891 "resolution preserves carried ID, time and source"
2892 );
2893 let prefix = journal
2894 .migrated_prefix_at_from_with_resolutions(&baseline, Seq(1), &[choice.clone()])
2895 .unwrap()
2896 .unwrap();
2897 assert!(
2898 !statement_ids(&prefix.graph.to_snapshot().resource_edges).contains("carried"),
2899 "future resolution does not invent a handle in an earlier prefix"
2900 );
2901 let mut effective = baseline.clone();
2902 replay_captured_deltas_onto(&mut effective, resolved.baseline_effects);
2903 for effects in resolved.entry_effects {
2904 replay_captured_deltas_onto(&mut effective, effects);
2905 }
2906 assert_eq!(
2907 effective.to_snapshot().resource_edges,
2908 resolved.graph.to_snapshot().resource_edges
2909 );
2910 let mut checkpoint = baseline.clone();
2911 journal
2912 .migrated_replay_from_with_baseline_and_resolutions(
2913 Seq(1),
2914 &mut checkpoint,
2915 &baseline,
2916 &[choice],
2917 )
2918 .unwrap();
2919 assert_eq!(
2920 statement_ids(&checkpoint.to_snapshot().resource_edges),
2921 BTreeSet::from(["carried".into()])
2922 );
2923 }
2924 let invalid = LegacyResourceOriginResolution {
2925 statement_id: "carried".into(),
2926 from_resource_id: ResourceNode::new("https://third.test/").id(),
2927 to_resource_id: parse_id(&diagnostic.current_resource_pair.1).unwrap(),
2928 };
2929 let mut unknown = invalid.clone();
2930 unknown.statement_id = "absent-handle".into();
2931 let earlier = LegacyResourceOriginResolution {
2932 statement_id: "carried".into(),
2933 from_resource_id: parse_id(&diagnostic.earlier_resource_pair.0).unwrap(),
2934 to_resource_id: parse_id(&diagnostic.earlier_resource_pair.1).unwrap(),
2935 };
2936 let later = LegacyResourceOriginResolution {
2937 from_resource_id: parse_id(&diagnostic.current_resource_pair.0).unwrap(),
2938 ..earlier.clone()
2939 };
2940 for choices in [vec![invalid], vec![unknown], vec![earlier, later]] {
2941 assert!(
2942 migrate_legacy_prefix_with_resolutions(&baseline, journal.entries(), &choices)
2943 .is_err()
2944 );
2945 assert!(
2946 journal
2947 .migrated_snapshot_at_from_with_resolutions(&baseline, Seq(1), &choices)
2948 .is_err()
2949 );
2950 let mut checkpoint = baseline.clone();
2951 let original = checkpoint.to_snapshot();
2952 let revision = checkpoint.revision();
2953 assert!(
2954 journal
2955 .migrated_replay_from_with_baseline_and_resolutions(
2956 Seq(0),
2957 &mut checkpoint,
2958 &baseline,
2959 &choices
2960 )
2961 .is_err()
2962 );
2963 assert_eq!(checkpoint.to_snapshot().edges, original.edges);
2964 assert_eq!(checkpoint.to_snapshot().resources, original.resources);
2965 assert_eq!(checkpoint.revision(), revision);
2966 }
2967 let error = migrate_legacy_prefix(&baseline, journal.entries())
2968 .err()
2969 .expect("direct adapter must hold unresolved linkage");
2970 assert!(error.to_string().contains("checkpoint C28"));
2971 assert!(
2972 journal
2973 .migrated_prefix_at_from(&baseline, journal.live_cursor())
2974 .is_err()
2975 );
2976 assert!(
2977 journal
2978 .migrated_snapshot_at_from(&baseline, journal.live_cursor())
2979 .is_err()
2980 );
2981 let mut checkpoint = baseline.clone();
2982 let checkpoint_author = Author::person("checkpoint-author");
2983 checkpoint.write_author = checkpoint_author.clone();
2984 checkpoint.current_session = 55;
2985 let seen = std::sync::Arc::new(std::sync::Mutex::new(Vec::<CapturedDelta>::new()));
2986 let sink = seen.clone();
2987 checkpoint.set_recorder(Some(std::sync::Arc::new(move |delta| {
2988 sink.lock().unwrap().push(delta.clone())
2989 })));
2990 let before_checkpoint = serde_json::to_value(checkpoint.to_snapshot()).unwrap();
2991 let before_revision = checkpoint.revision();
2992 let before_url_revision = checkpoint.url_grouping_revision();
2993 assert!(
2994 journal
2995 .migrated_replay_from_with_baseline(Seq(0), &mut checkpoint, &baseline)
2996 .is_err()
2997 );
2998 let mut after_checkpoint = serde_json::to_value(checkpoint.to_snapshot()).unwrap();
2999 after_checkpoint["timestamp_secs"] = before_checkpoint["timestamp_secs"].clone();
3000 assert_eq!(
3001 after_checkpoint, before_checkpoint,
3002 "failed checkpoint replay leaves the whole graph unchanged"
3003 );
3004 assert_eq!(checkpoint.revision(), before_revision);
3005 assert_eq!(checkpoint.url_grouping_revision(), before_url_revision);
3006 assert_eq!(checkpoint.write_author, checkpoint_author);
3007 assert_eq!(checkpoint.current_session, 55);
3008 assert!(checkpoint.is_recording());
3009 assert!(seen.lock().unwrap().is_empty());
3010 assert_eq!(
3011 serde_json::to_vec(journal.entries()).unwrap(),
3012 source_before
3013 );
3014 let witness = CapturedDelta::ReplaySetNodeTitleById {
3015 node_id: Uuid::from_u128(1).to_string(),
3016 title: "recorder remains live".into(),
3017 };
3018 super::super::apply::apply_graph_delta(
3019 &mut checkpoint,
3020 witness.replay().into_write().unwrap(),
3021 );
3022 assert_eq!(
3023 *seen.lock().unwrap(),
3024 vec![witness],
3025 "a real edit proves the retained recorder works"
3026 );
3027 let mut marker = carried.clone();
3028 marker.assertions.statements[0].provenance_iri =
3029 Some(super::super::edge_data::UNKNOWN_LEGACY_ASSERTER_IRI.into());
3030 let mut uncertain = journal.entries()[..2].to_vec();
3031 uncertain.push(AttributedDelta {
3032 author: Author::person("later-author"),
3033 delta: exact(1, 2, &marker),
3034 });
3035 let unknown = probe_legacy_mint_links(&baseline, &uncertain).unwrap();
3036 assert_eq!(
3037 unknown.len(),
3038 1,
3039 "unknown legacy attribution cannot suppress earlier mint evidence"
3040 );
3041 assert!(!unknown[0].explicit_source_matches);
3042 assert!(migrate_legacy_prefix(&baseline, &uncertain).is_err());
3043 marker.assertions.statements[0].provenance_iri =
3044 Some(Author::person("different-author").asserter_iri());
3045 uncertain[2].delta = exact(1, 2, &marker);
3046 assert!(
3047 probe_legacy_mint_links(&baseline, &uncertain)
3048 .unwrap()
3049 .is_empty(),
3050 "a concrete different Author is a distinct claim control"
3051 );
3052 let author_control = migrate_legacy_prefix(&baseline, &uncertain).unwrap();
3053 assert_eq!(
3054 statement_ids(&author_control.graph.to_snapshot().resource_edges),
3055 BTreeSet::from(["carried".into()])
3056 );
3057 carried.assertions.statements[0].predicate = "https://vocab.test/distinct".into();
3059 carried.assertions.statements[0].recognized_sub_kind = None;
3060 let mut independent = journal.entries()[..2].to_vec();
3061 independent.push(AttributedDelta {
3062 author,
3063 delta: exact(1, 2, &carried),
3064 });
3065 assert!(
3066 probe_legacy_mint_links(&baseline, &independent)
3067 .unwrap()
3068 .is_empty()
3069 );
3070 let predicate_control = migrate_legacy_prefix(&baseline, &independent).unwrap();
3071 assert_eq!(
3072 statement_ids(&predicate_control.graph.to_snapshot().resource_edges),
3073 BTreeSet::from(["carried".into()])
3074 );
3075 }
3076}