World's first open-source enterprise world model.
Rust agent-memorybitemporalgraphragknowledge-baseknowledge-graphllmontologypgvectorpostgresqlragrustself-hostedsemantic-searchtemporal-knowledge-graphworld-model
Preserve literal objects when exporting unbound statements (#821)
Maya Kidcbf4969ef99d
diff --git a/crates/utopia-server/src/api/mcp_tests.rs b/crates/utopia-server/src/api/mcp_tests.rsindex 99528a28..18f269bb 100644--- a/crates/utopia-server/src/api/mcp_tests.rs+++ b/crates/utopia-server/src/api/mcp_tests.rs@@ -1632,3 +1632,156 @@ async fn rule_matches_keep_materialized_intervals_and_count_rows() -> anyhow::Re);f.clean().await}++// Reuse the authenticated ledger fixture so RDF exercises the same stored records+// as structured MCP reads, including evidence and retracted history.+#[tokio::test]+async fn rdf_export_preserves_unbound_literal_objects() -> anyhow::Result<()> {+ use axum::body::{to_bytes, Body};+ use axum::http::{Request, StatusCode};+ use oxrdf::{vocab::rdf, Literal, Term};+ use tower::ServiceExt;++ let Some(f) = Fixture::new().await? else {+ return Ok(());+ };+ async fn check(f: &Fixture) -> anyhow::Result<()> {+ let value = json!({"value": "待复检"});+ let (statement, _) = utopia_store::graph::insert_open_statement(+ &f.state.pool,+ f.kb,+ f.subject,+ "状态",+ utopia_store::graph::FactObject::Value(&value),+ Some("2026-01-01T00:00:00Z".parse()?),+ 0.9,+ )+ .await?;+ sqlx::query("UPDATE facts SET recorded_at='2026-02-01' WHERE id=$1")+ .bind(statement)+ .execute(&f.state.pool)+ .await?;+ sqlx::query(+ "INSERT INTO fact_evidence(fact_id,chunk_id,document_id,doc_version,quote)+ VALUES ($1,$2,$3,1,'设备 A 待复检')",+ )+ .bind(statement)+ .bind(f.chunk)+ .bind(f.document)+ .execute(&f.state.pool)+ .await?;+ let auth = utopia_store::tokens::authenticate(&f.state.pool, &f.token).await?;+ let jwt = crate::auth::issue_token(&f.state, auth.user_id)?;+ let app = crate::api::router(f.state.clone(), &Default::default());+ let names = crate::rdf::Names::new(f.kb, None).map_err(anyhow::Error::msg)?;+ let stmt = names.fact(statement);+ let mut formats = Vec::new();+ for retracted in [false, true] {+ if retracted {+ sqlx::query("UPDATE facts SET invalidated_at='2026-03-01' WHERE id=$1")+ .bind(statement)+ .execute(&f.state.pool)+ .await?;+ }+ // Snapshot every KB-scoped business table, including queues and adoption+ // records. Request audit is deliberately excluded from this read-only check.+ let tables: Vec<String> = sqlx::query_scalar(+ "SELECT table_name FROM information_schema.columns+ WHERE table_schema='public' AND column_name='kb_id'+ AND table_name <> 'audit_events' ORDER BY table_name",+ )+ .fetch_all(&f.state.pool)+ .await?;+ let snapshot = async {+ let mut rows = Vec::new();+ for table in &tables {+ let sql = format!("SELECT COALESCE(jsonb_agg(to_jsonb(t) ORDER BY to_jsonb(t)::text), '[]'::jsonb) FROM \"{}\" t WHERE kb_id=$1", table.replace('"', "\"\""));+ rows.push(+ sqlx::query_scalar::<_, Value>(&sql)+ .bind(f.kb)+ .fetch_one(&f.state.pool)+ .await?,+ );+ }+ Ok::<_, anyhow::Error>(rows)+ };+ let before = snapshot.await?;+ let extra_sql = "SELECT jsonb_build_array(+ (SELECT COALESCE(jsonb_agg(to_jsonb(e) ORDER BY to_jsonb(e)::text), '[]')+ FROM fact_evidence e JOIN facts f ON f.id=e.fact_id WHERE f.kb_id=$1),+ (SELECT COALESCE(jsonb_agg(to_jsonb(j) ORDER BY j.id), '[]') FROM jobs j+ WHERE payload->>'kb_id'=$1::text OR payload->>'document_id' IN+ (SELECT id::text FROM documents WHERE kb_id=$1)))";+ let extra_before: Value = sqlx::query_scalar(extra_sql)+ .bind(f.kb)+ .fetch_one(&f.state.pool)+ .await?;+ for format in ["turtle", "jsonld"] {+ let response = app+ .clone()+ .oneshot(+ Request::builder()+ .uri(format!("/api/v1/kbs/{}/export?format={format}", f.kb))+ .header("authorization", format!("Bearer {jwt}"))+ .body(Body::empty())?,+ )+ .await?;+ anyhow::ensure!(response.status() == StatusCode::OK, "export rejected");+ let bytes = to_bytes(response.into_body(), 1024 * 1024).await?;+ let format = if format == "turtle" {+ oxrdfio::RdfFormat::Turtle+ } else {+ oxrdfio::RdfFormat::JsonLd {+ profile: oxrdfio::JsonLdProfileSet::empty(),+ }+ };+ let quads = oxrdfio::RdfParser::from_format(format)+ .for_slice(&bytes)+ .collect::<Result<std::collections::HashSet<_>, _>>()?;+ anyhow::ensure!(+ quads.iter().any(|q| q.subject == stmt.clone().into()+ && q.predicate == rdf::OBJECT+ && q.object == Term::Literal(Literal::new_simple_literal("待复检"))),+ "unbound statement lost its rdf:object in authenticated export"+ );+ anyhow::ensure!(+ !quads+ .iter()+ .any(|q| q.subject == stmt.clone().into() && q.predicate == rdf::PREDICATE),+ "invented a bound predicate"+ );+ anyhow::ensure!(+ quads.iter().any(|q| q.subject == stmt.clone().into()+ && q.predicate.as_str() == "http://www.w3.org/ns/prov#wasDerivedFrom"+ && q.object == names.document(f.document).into()),+ "lost evidence source"+ );+ formats.push(quads);+ }+ anyhow::ensure!(+ formats[formats.len() - 1] == formats[formats.len() - 2],+ "formats disagree"+ );+ let extra_after: Value = sqlx::query_scalar(extra_sql)+ .bind(f.kb)+ .fetch_one(&f.state.pool)+ .await?;+ anyhow::ensure!(+ extra_before == extra_after,+ "export changed evidence or jobs"+ );+ for (table, expected) in tables.iter().zip(before) {+ let sql = format!("SELECT COALESCE(jsonb_agg(to_jsonb(t) ORDER BY to_jsonb(t)::text), '[]'::jsonb) FROM \"{}\" t WHERE kb_id=$1", table.replace('"', "\"\""));+ let actual: Value = sqlx::query_scalar(&sql)+ .bind(f.kb)+ .fetch_one(&f.state.pool)+ .await?;+ anyhow::ensure!(actual == expected, "export changed {table}");+ }+ }+ Ok(())+ }+ let result = check(&f).await;+ let cleanup = f.clean().await;+ result.and(cleanup)+}diff --git a/crates/utopia-server/src/rdf.rs b/crates/utopia-server/src/rdf.rsindex 8be69b9b..bec9ff7a 100644--- a/crates/utopia-server/src/rdf.rs+++ b/crates/utopia-server/src/rdf.rs@@ -453,10 +453,11 @@ pub fn emit_fact(let predicate = f.predicate_id.and_then(|p| vocab.relation(p)).cloned();let object: Option<Term> = match (f.object_id, &f.object_value) {(Some(o), _) => Some(names.entity(o).into()),- (None, Some(v)) => f.predicate_id.map(|p| {- let (datatype, _) = vocab.literal_shape(p);- literal_value(v, datatype).into()- }),+ (None, Some(v)) => {+ // An unbound statement still has an object; only its datatype is unknown.+ let datatype = f.predicate_id.and_then(|p| vocab.literal_shape(p).0);+ Some(literal_value(v, datatype).into())+ }_ => None,};@@ -801,6 +802,100 @@ mod tests {const OBJ: &str = "<urn:utopia:kb:01a06dc4-f40a-7013-b09f-1b499e2e7441:entity:0b0b0b0b-0b0b-0b0b-0b0b-0b0b0b0b0b0b>";const WORKS_FOR: &str = "https://schema.org/worksFor";+ #[test]+ fn unbound_literal_objects_survive_both_formats() {+ for value in [+ serde_json::json!({"value": "待复检"}),+ serde_json::json!({"value": "quote: \" and slash: \\"}),+ serde_json::json!({"value": ""}),+ serde_json::json!({"value": 0}),+ serde_json::json!({"value": false}),+ serde_json::json!({"value": null, "summary": "not specified"}),+ serde_json::Value::Null,+ ] {+ let mut f = fact(5);+ f.predicate_id = None;+ f.surface_predicate = Some("状态".into());+ f.object_id = None;+ f.object_value = Some(value.clone());+ f.documents = vec![id(20)];+ f.quotes = vec!["设备 A 待复检".into()];+ f.supersedes = Some(id(6));+ for retracted in [false, true] {+ f.invalidated_at = retracted.then(|| at("2026-02-01T00:00:00Z"));+ let mut sets = Vec::new();+ for format in [Format::Turtle, Format::JsonLd] {+ let quads = export(format, |sink, names, vocab| {+ emit_fact(sink, names, vocab, &f, at("2026-06-01T00:00:00Z")).unwrap();+ });+ assert_eq!(+ objects(&quads, STMT, rdf::OBJECT.as_str()),+ vec![literal_value(&value, None).to_string()],+ "unbound statement lost its literal object: {value}"+ );+ assert!(objects(&quads, STMT, rdf::PREDICATE.as_str()).is_empty());+ assert!(!quads.iter().any(|q| q.subject.to_string() == SUBJ));+ sets.push(quads.into_iter().collect::<std::collections::HashSet<_>>());+ }+ assert_eq!(sets[0], sets[1]);+ }+ }+ }++ #[test]+ fn bound_literal_datatypes_survive_both_formats() {+ for (datatype, value, expected) in [+ (+ "number",+ serde_json::json!(0),+ Literal::new_typed_literal("0", xsd::DECIMAL),+ ),+ (+ "text",+ serde_json::json!("待复检"),+ Literal::new_simple_literal("待复检"),+ ),+ (+ "bool",+ serde_json::json!(false),+ Literal::new_typed_literal("false", xsd::BOOLEAN),+ ),+ ] {+ let mut f = fact(5);+ f.predicate_id = Some(id(4));+ f.object_id = None;+ f.object_value = Some(serde_json::json!({"value": value}));+ for format in [Format::Turtle, Format::JsonLd] {+ let quads = export(format, |sink, names, _| {+ let mut property = relation(4, "value", None, "attribute");+ property.datatype = Some(datatype.into());+ let vocab = vocabulary(names, &[], &[property]);+ emit_fact(sink, names, &vocab, &f, at("2026-06-01T00:00:00Z")).unwrap();+ });+ assert_eq!(+ objects(&quads, STMT, rdf::OBJECT.as_str()),+ vec![expected.to_string()]+ );+ assert!(quads.iter().any(|q| q.subject.to_string() == SUBJ+ && q.object == Term::Literal(expected.clone())));+ }+ }+ }++ #[test]+ fn an_absent_object_is_not_an_empty_literal() {+ let mut f = fact(5);+ f.predicate_id = None;+ f.object_id = None;+ f.object_value = None;+ for format in [Format::Turtle, Format::JsonLd] {+ let quads = export(format, |sink, names, vocab| {+ emit_fact(sink, names, vocab, &f, at("2026-06-01T00:00:00Z")).unwrap();+ });+ assert!(objects(&quads, STMT, rdf::OBJECT.as_str()).is_empty());+ }+ }+#[test]fn an_imported_class_keeps_its_own_iri() {let quads = export(Format::Turtle, |_, _, _| {});