Skip to content

Plan, apply and roll back changes to a production ontology, with a blast radius report and a proof an auditor can re-check.

fix(version): retain dataset graph contexts in snapshots

Rudy Celekli170a34e375f3
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 3d864085..287abc01 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -46,6 +46,11 @@ All notable changes to Open Ontologies are documented here.
### Fixed
+- Save ontology versions as N-Quads and restore their stored format, preserving
+ named graphs and repeated facts in separate contexts. Legacy N-Triples
+ snapshots remain readable.
+
+
- **The embedding model is loaded once per process rather than once per HTTP
session** (#262). The HTTP arm hands the same server constructor to
`StreamableHttpService::new` as a per-session factory, so everything that
diff --git a/src/ontology.rs b/src/ontology.rs
index e1f33ee9..2b27119e 100644
--- a/src/ontology.rs
+++ b/src/ontology.rs
@@ -240,12 +240,12 @@ impl OntologyService {
/// Save a named version (snapshot) of the current graph store.
pub fn save_version(db: &StateDb, store: &Arc<GraphStore>, label: &str) -> anyhow::Result<String> {
- let content = store.snapshot("ntriples")?;
+ let content = store.snapshot("nquads")?;
let count = store.triple_count();
let conn = db.conn();
conn.execute(
"INSERT INTO ontology_versions (label, triple_count, content, format) VALUES (?1, ?2, ?3, ?4)",
- rusqlite::params![label, count as i64, content, "ntriples"],
+ rusqlite::params![label, count as i64, content, "nquads"],
)?;
Ok(serde_json::json!({
"ok": true,
@@ -275,13 +275,18 @@ impl OntologyService {
/// Rollback the graph store to a previously saved version.
pub fn rollback_version(db: &StateDb, store: &Arc<GraphStore>, label: &str) -> anyhow::Result<String> {
let conn = db.conn();
- let content: String = conn.query_row(
- "SELECT content FROM ontology_versions WHERE label = ?1 ORDER BY id DESC LIMIT 1",
+ let (content, format): (String, String) = conn.query_row(
+ "SELECT content, format FROM ontology_versions WHERE label = ?1 ORDER BY id DESC LIMIT 1",
rusqlite::params![label],
- |row| row.get(0),
+ |row| Ok((row.get(0)?, row.get(1)?)),
)?;
+ let rdf_format = match format.as_str() {
+ "nquads" => RdfFormat::NQuads,
+ "ntriples" => RdfFormat::NTriples,
+ _ => anyhow::bail!("unsupported saved version format: {format}"),
+ };
store.clear()?;
- let count = store.load_ntriples(&content)?;
+ let count = store.load_content(&content, rdf_format)?;
Ok(serde_json::json!({
"ok": true,
"label": label,
diff --git a/tests/version_dataset_roundtrip_test.rs b/tests/version_dataset_roundtrip_test.rs
new file mode 100644
index 00000000..e0afd0ab
--- /dev/null
+++ b/tests/version_dataset_roundtrip_test.rs
@@ -0,0 +1,220 @@
+mod common;
+
+use serde_json::{Value, json};
+use std::process::Stdio;
+use tokio::io::{AsyncBufReadExt, AsyncWriteExt, BufReader};
+
+struct Mcp {
+ child: tokio::process::Child,
+ stdin: tokio::process::ChildStdin,
+ stdout: tokio::io::Lines<BufReader<tokio::process::ChildStdout>>,
+ next_id: u64,
+}
+
+impl Mcp {
+ async fn start(directory: &std::path::Path) -> Self {
+ let (child, stdin, stdout) = {
+ let _gate = common::exec_gate();
+ let config = directory.join("config.toml");
+ std::fs::write(
+ &config,
+ format!(
+ "[cache]\ndir = {}\n[embeddings]\nmodel_path = {}\ntokenizer_path = {}\n",
+ json!(directory.join("cache").to_string_lossy()),
+ json!(directory.join("absent.onnx").to_string_lossy()),
+ json!(directory.join("absent-tokenizer.json").to_string_lossy()),
+ ),
+ )
+ .unwrap();
+ let mut child = tokio::process::Command::new(env!("CARGO_BIN_EXE_open-ontologies"))
+ .args(["--no-connect", "--data-dir"])
+ .arg(directory)
+ .args(["serve", "--config"])
+ .arg(config)
+ .stdin(Stdio::piped())
+ .stdout(Stdio::piped())
+ .stderr(Stdio::inherit())
+ .kill_on_drop(true)
+ .spawn()
+ .unwrap();
+ let stdin = child.stdin.take().unwrap();
+ let stdout = BufReader::new(child.stdout.take().unwrap()).lines();
+ (child, stdin, stdout)
+ };
+ let mut session = Self {
+ child,
+ stdin,
+ stdout,
+ next_id: 1,
+ };
+ session.request("initialize", json!({"protocolVersion":"2025-03-26", "capabilities":{}, "clientInfo":{"name":"version-dataset-test", "version":"1"}})).await;
+ session
+ .write(json!({"jsonrpc":"2.0", "method":"notifications/initialized"}))
+ .await;
+ session
+ }
+
+ async fn write(&mut self, message: Value) {
+ self.stdin
+ .write_all(message.to_string().as_bytes())
+ .await
+ .unwrap();
+ self.stdin.write_all(b"\n").await.unwrap();
+ self.stdin.flush().await.unwrap();
+ }
+
+ async fn request(&mut self, method: &str, params: Value) -> Value {
+ let id = self.next_id;
+ self.next_id += 1;
+ self.write(json!({"jsonrpc":"2.0", "id":id, "method":method, "params":params}))
+ .await;
+ loop {
+ let line =
+ tokio::time::timeout(std::time::Duration::from_secs(20), self.stdout.next_line())
+ .await
+ .expect("MCP response timeout")
+ .unwrap()
+ .expect("MCP output closed");
+ let response: Value = serde_json::from_str(&line).unwrap();
+ if response["id"] == id {
+ assert!(response.get("error").is_none(), "{response}");
+ return response["result"].clone();
+ }
+ }
+ }
+
+ async fn call(&mut self, name: &str, arguments: Value) -> Value {
+ let result = self
+ .request("tools/call", json!({"name":name, "arguments":arguments}))
+ .await;
+ let value: Value =
+ serde_json::from_str(result["content"][0]["text"].as_str().unwrap()).unwrap();
+ assert!(value.get("error").is_none(), "{value}");
+ value
+ }
+}
+
+use open_ontologies::graph::GraphStore;
+use open_ontologies::ontology::OntologyService;
+use open_ontologies::state::StateDb;
+use std::sync::Arc;
+
+const DATASET: &str = r#"
+@prefix ex: <https://example.org/> .
+@prefix owl: <http://www.w3.org/2002/07/owl#> .
+ex:Order a owl:Class .
+ex:warehouse { ex:order-1 ex:status "pending" . }
+ex:store { ex:order-1 ex:status "pending" . }
+"#;
+const DEFAULT: &str = "<https://example.org/order-1> <https://example.org/status> \"pending\" .";
+const NAMED_QUERY: &str = "SELECT ?g ?s ?status WHERE { GRAPH ?g { ?s <https://example.org/status> ?status } } ORDER BY ?g";
+const DEFAULT_QUERY: &str = "SELECT ?s ?status WHERE { ?s <https://example.org/status> ?status }";
+
+fn snapshot_lines(graph: &GraphStore) -> std::collections::BTreeSet<String> {
+ graph
+ .serialize("nquads")
+ .unwrap()
+ .lines()
+ .map(String::from)
+ .collect()
+}
+
+#[test]
+fn saved_versions_retain_default_named_and_inferred_graphs_without_collapsing_facts() {
+ let tmp = tempfile::tempdir().unwrap();
+ let db = StateDb::open(&tmp.path().join("state.db")).unwrap();
+ for (name, source, format, count) in [
+ (
+ "dataset",
+ DATASET.to_string(),
+ oxigraph::io::RdfFormat::TriG,
+ 3,
+ ),
+ (
+ "default",
+ DEFAULT.to_string(),
+ oxigraph::io::RdfFormat::NTriples,
+ 1,
+ ),
+ (
+ "inferred",
+ format!(
+ "<https://example.org/order-1> <https://example.org/derivedStatus> \"pending\" <{}> .",
+ open_ontologies::reason::INFERRED_GRAPH
+ ),
+ oxigraph::io::RdfFormat::NQuads,
+ 1,
+ ),
+ ] {
+ let graph = Arc::new(GraphStore::new());
+ assert_eq!(graph.load_content(&source, format).unwrap(), count);
+ let expected = snapshot_lines(&graph);
+ let saved: Value =
+ serde_json::from_str(&OntologyService::save_version(&db, &graph, name).unwrap())
+ .unwrap();
+ assert_eq!(saved["triple_count"], count);
+ let history: Value =
+ serde_json::from_str(&OntologyService::list_versions(&db).unwrap()).unwrap();
+ assert_eq!(history["versions"][0]["format"], "nquads");
+ graph.clear().unwrap();
+ graph
+ .load_turtle(
+ "<https://example.org/temporary> <https://example.org/status> \"changed\" .",
+ None,
+ )
+ .unwrap();
+ let restored: Value =
+ serde_json::from_str(&OntologyService::rollback_version(&db, &graph, name).unwrap())
+ .unwrap();
+ assert_eq!(restored["triples_restored"], count);
+ assert_eq!(graph.triple_count(), count);
+ assert_eq!(snapshot_lines(&graph), expected);
+ }
+}
+
+#[test]
+fn legacy_ntriples_versions_remain_readable() {
+ let tmp = tempfile::tempdir().unwrap();
+ let db = StateDb::open(&tmp.path().join("state.db")).unwrap();
+ db.conn().execute("INSERT INTO ontology_versions (label, triple_count, content, format) VALUES (?1, ?2, ?3, ?4)", rusqlite::params!["legacy", 1, DEFAULT, "ntriples"]).unwrap();
+ let graph = Arc::new(GraphStore::new());
+ graph
+ .load_turtle(
+ "<https://example.org/temporary> <https://example.org/status> \"changed\" .",
+ None,
+ )
+ .unwrap();
+ let restored: Value =
+ serde_json::from_str(&OntologyService::rollback_version(&db, &graph, "legacy").unwrap())
+ .unwrap();
+ assert_eq!(restored["triples_restored"], 1);
+ assert_eq!(graph.triple_count(), 1);
+ let rows: Value = serde_json::from_str(&graph.sparql_select(DEFAULT_QUERY).unwrap()).unwrap();
+ assert_eq!(rows["results"].as_array().unwrap().len(), 1);
+ assert_eq!(rows["results"][0]["s"], "<https://example.org/order-1>");
+}
+
+#[tokio::test]
+async fn public_mcp_version_and_rollback_preserve_dataset_query_scopes() {
+ let tmp = tempfile::tempdir().unwrap();
+ let path = tmp.path().join("orders.trig");
+ std::fs::write(&path, DATASET).unwrap();
+ let mut mcp = Mcp::start(tmp.path()).await;
+ let loaded = mcp.call("onto_load", json!({"path":path})).await;
+ assert_eq!(loaded["triples_loaded"], 3);
+ let before = mcp.call("onto_query", json!({"query":NAMED_QUERY})).await;
+ assert_eq!(before["results"].as_array().unwrap().len(), 2);
+ let empty_default = mcp.call("onto_query", json!({"query":DEFAULT_QUERY})).await;
+ assert!(empty_default["results"].as_array().unwrap().is_empty());
+ let saved = mcp.call("onto_version", json!({"label":"dataset"})).await;
+ assert_eq!(saved["triple_count"], 3);
+ let restored = mcp.call("onto_rollback", json!({"label":"dataset"})).await;
+ assert_eq!(restored["triples_restored"], 3);
+ let after = mcp.call("onto_query", json!({"query":NAMED_QUERY})).await;
+ assert_eq!(after, before);
+ let after_default = mcp.call("onto_query", json!({"query":DEFAULT_QUERY})).await;
+ assert_eq!(after_default, empty_default);
+ let history = mcp.call("onto_history", json!({})).await;
+ assert_eq!(history["versions"][0]["format"], "nquads");
+ mcp.child.kill().await.unwrap();
+}