1use std::collections::HashMap;
2
3use serde::Serialize;
4use uuid::Uuid;
5
6use khive_db::stores::graph::edge_hard_delete_statement;
7use khive_storage::graph::{SymmetricEdgeUpdateOutcome, SymmetricEdgeUpdateRequest};
8use khive_storage::types::{
9 DeleteMode, EdgeSortField, LinkId, PageRequest, SeekCursor, SortOrder, SqlRow, SqlStatement,
10 SqlValue,
11};
12use khive_storage::{Edge, EdgeRelation};
13use khive_types::{EventKind, SubstrateKind};
14
15use crate::error::{RuntimeError, RuntimeResult};
16use crate::runtime::{KhiveRuntime, NamespaceToken};
17
18use super::{canonical_edge_endpoints, static_impossible_edge_pattern_warnings, EdgeReadWindow};
19
20#[derive(Clone, Debug, Serialize)]
22pub struct QueryResult {
23 pub rows: Vec<SqlRow>,
24 #[serde(skip_serializing_if = "Vec::is_empty")]
25 pub warnings: Vec<String>,
26 pub offset: usize,
28 pub page_size: usize,
30 pub has_more: bool,
32 #[serde(skip_serializing_if = "Option::is_none")]
34 pub next_offset: Option<usize>,
35 pub truncated: bool,
37}
38
39impl KhiveRuntime {
40 pub async fn query(&self, token: &NamespaceToken, query: &str) -> RuntimeResult<Vec<SqlRow>> {
48 Ok(self
49 .query_with_metadata(token, query, khive_query::CompileOptions::default())
50 .await?
51 .rows)
52 }
53
54 pub async fn query_with_metadata(
56 &self,
57 token: &NamespaceToken,
58 query: &str,
59 mut opts: khive_query::CompileOptions,
60 ) -> RuntimeResult<QueryResult> {
61 use khive_query::QueryValue;
62 use khive_storage::types::SqlValue;
63
64 let (language, ast) = khive_query::language::parse_auto_with_language(query)?;
65 if opts.max_limit == 0 {
66 return Err(RuntimeError::InvalidInput(
67 "query page size must be at least 1".into(),
68 ));
69 }
70 let offset = ast.offset;
71 let page_size = ast.limit.unwrap_or(opts.max_limit).min(opts.max_limit);
72 opts.scopes = token
73 .visible_namespaces()
74 .iter()
75 .map(|ns| ns.as_str().to_string())
76 .collect();
77 let mailbox = crate::MailboxView {
78 actor_id: token.actor().id.clone(),
79 delegated: false,
80 }
81 .note_scope(token);
82 let compiled = khive_query::compile_with_mailbox(
83 &ast,
84 &opts,
85 &khive_query::QueryMailboxScope {
86 actor_id: mailbox.actor_id,
87 legacy_local: mailbox.legacy_local,
88 },
89 )?;
90 let mut warnings = compiled.warnings;
91 let truncation_check = compiled.truncation_check;
92
93 warnings.extend(self.with_pack_edge_rules(|pack_rules| {
94 static_impossible_edge_pattern_warnings(language, &ast.pattern, pack_rules)
95 }));
96
97 let params: Vec<SqlValue> = compiled
100 .params
101 .into_iter()
102 .map(|qv| match qv {
103 QueryValue::Null => SqlValue::Null,
104 QueryValue::Integer(n) => SqlValue::Integer(n),
105 QueryValue::Float(f) => SqlValue::Float(f),
106 QueryValue::Text(s) => SqlValue::Text(s),
107 QueryValue::Blob(b) => SqlValue::Blob(b),
108 })
109 .collect();
110
111 let mut reader = self.sql().reader().await?;
112 let stmt = SqlStatement {
113 sql: compiled.sql,
114 params,
115 label: None,
116 };
117 let mut rows = reader.query_all(stmt).await?;
118
119 let mut truncated = false;
123 if let Some(check) = truncation_check {
124 if rows.len() > check.max_limit {
125 rows.truncate(check.max_limit);
126 truncated = true;
127 }
128 }
129
130 let next_offset = if truncated && language == khive_query::QueryLanguage::Gql {
131 let next = offset.checked_add(rows.len()).ok_or_else(|| {
132 RuntimeError::InvalidInput("GQL next_offset exceeds usize::MAX".into())
133 })?;
134 if next == offset {
135 return Err(RuntimeError::InvalidInput(
136 "query page did not advance; page size must be at least 1".into(),
137 ));
138 }
139 i64::try_from(next).map_err(|_| {
140 RuntimeError::InvalidInput("GQL next_offset exceeds i64::MAX".into())
141 })?;
142 Some(next)
143 } else {
144 None
145 };
146
147 if truncated {
148 let Some(check) = truncation_check else {
149 return Err(RuntimeError::Internal(
150 "truncated query result is missing sentinel metadata".into(),
151 ));
152 };
153 let bound = match check.requested_limit {
154 Some(requested) => {
155 format!("requested query LIMIT {requested} exceeds the effective page size")
156 }
157 None => "the query has no explicit LIMIT".to_string(),
158 };
159 let warning = match language {
160 khive_query::QueryLanguage::Gql => {
161 let Some(next) = next_offset else {
162 return Err(RuntimeError::Internal(
163 "truncated GQL result is missing its continuation offset".into(),
164 ));
165 };
166 format!(
167 "result page capped at {} rows because {bound}; more matches exist. \
168 Continue the same GQL query with `SKIP {next}` (the machine-readable \
169 `next_offset`) and keep the same page size.",
170 check.max_limit
171 )
172 }
173 khive_query::QueryLanguage::Sparql => format!(
174 "result page capped at {} rows because {bound}; more matches exist. \
175 SPARQL OFFSET paging is not part of the supported dialect.",
176 check.max_limit
177 ),
178 };
179 warnings.push(warning);
180 }
181
182 Ok(QueryResult {
183 rows,
184 warnings,
185 offset,
186 page_size,
187 has_more: truncated,
188 next_offset,
189 truncated,
190 })
191 }
192
193 pub async fn get_edge(
200 &self,
201 _token: &NamespaceToken,
202 edge_id: Uuid,
203 ) -> RuntimeResult<Option<Edge>> {
204 self.get_edge_by_id_inner(edge_id, false).await
205 }
206
207 pub async fn get_edges_by_id(
216 &self,
217 _token: &NamespaceToken,
218 ids: &[Uuid],
219 ) -> RuntimeResult<Vec<Option<Edge>>> {
220 let mut edges = Vec::with_capacity(ids.len());
221 for chunk in ids.chunks(900) {
222 let window = self.prepare_edge_read_window(chunk).await?;
223 edges.extend(
224 Self::hydrate_edge_read_window(chunk, window, |record_token| {
225 self.graph(record_token)
226 })
227 .await?,
228 );
229 }
230 Ok(edges)
231 }
232
233 pub(super) async fn prepare_edge_read_window(
234 &self,
235 ids: &[Uuid],
236 ) -> RuntimeResult<EdgeReadWindow> {
237 let placeholders = (1..=ids.len())
238 .map(|index| format!("?{index}"))
239 .collect::<Vec<_>>()
240 .join(",");
241 let mut reader = self.sql().reader().await?;
242 let rows = reader
243 .query_all(SqlStatement {
244 sql: format!(
245 "SELECT id, namespace FROM graph_edges WHERE id IN ({placeholders}) AND deleted_at IS NULL"
246 ),
247 params: ids.iter().map(|id| SqlValue::Text(id.to_string())).collect(),
248 label: Some("get_edge_namespace".into()),
249 })
250 .await?;
251 let mut namespaces = HashMap::with_capacity(rows.len());
252 for row in rows {
253 let Some(SqlValue::Text(id)) = row.columns.first().map(|column| &column.value) else {
254 return Err(RuntimeError::Internal(
255 "edge namespace lookup returned an invalid id".into(),
256 ));
257 };
258 let id = Uuid::parse_str(id).map_err(|e| {
259 RuntimeError::Internal(format!("edge namespace lookup returned an invalid id: {e}"))
260 })?;
261 let value = row
262 .columns
263 .get(1)
264 .map(|column| column.value.clone())
265 .unwrap_or(SqlValue::Null);
266 namespaces.insert(id, value);
267 }
268 let mut window = EdgeReadWindow {
269 outcomes: (0..ids.len()).map(|_| Some(Ok(None))).collect(),
270 groups: Vec::new(),
271 };
272 let mut group_indices = HashMap::new();
273 for (index, id) in ids.iter().enumerate() {
274 let Some(SqlValue::Text(record_ns)) = namespaces.get(id) else {
275 continue;
276 };
277 match khive_types::Namespace::parse(record_ns) {
278 Ok(namespace) => {
279 let next_group = window.groups.len();
280 let group = *group_indices.entry(record_ns.clone()).or_insert(next_group);
281 if group == next_group {
282 window.groups.push((namespace, Vec::new()));
283 }
284 window.groups[group].1.push(index);
285 window.outcomes[index] = None;
286 }
287 Err(error) => {
288 window.outcomes[index] = Some(Err(RuntimeError::Internal(format!(
289 "edge namespace invalid: {error}"
290 ))));
291 }
292 }
293 }
294 Ok(window)
295 }
296
297 pub(super) async fn hydrate_edge_read_window<F>(
298 ids: &[Uuid],
299 mut window: EdgeReadWindow,
300 mut graph: F,
301 ) -> RuntimeResult<Vec<Option<Edge>>>
302 where
303 F: FnMut(&NamespaceToken) -> RuntimeResult<std::sync::Arc<dyn khive_storage::GraphStore>>,
304 {
305 for (namespace, indices) in window.groups {
306 let record_token = NamespaceToken::for_namespace(namespace);
307 let group_ids: Vec<LinkId> = indices
308 .iter()
309 .map(|&index| LinkId::from(ids[index]))
310 .collect();
311 let outcomes = match graph(&record_token) {
312 Ok(store) => store
313 .get_edge_read_outcomes(&group_ids)
314 .await
315 .map_err(RuntimeError::from),
316 Err(error) => Err(error),
317 };
318 match outcomes {
319 Ok(outcomes) if outcomes.len() == indices.len() => {
320 for (index, outcome) in indices.into_iter().zip(outcomes) {
321 window.outcomes[index] = Some(outcome.map_err(RuntimeError::from));
322 }
323 }
324 Ok(_) => {
325 window.outcomes[indices[0]] = Some(Err(RuntimeError::Internal(
326 "edge batch returned an invalid outcome count".into(),
327 )));
328 }
329 Err(error) => {
330 window.outcomes[indices[0]] = Some(Err(error));
331 }
332 }
333 }
334 window
335 .outcomes
336 .into_iter()
337 .map(|outcome| {
338 outcome.unwrap_or_else(|| {
339 Err(RuntimeError::Internal(
340 "edge batch omitted an input outcome".into(),
341 ))
342 })
343 })
344 .collect()
345 }
346
347 pub async fn get_edge_visible(
352 &self,
353 token: &NamespaceToken,
354 edge_id: Uuid,
355 ) -> RuntimeResult<Option<Edge>> {
356 self.get_edge(token, edge_id).await
357 }
358
359 pub async fn get_edge_including_deleted(
365 &self,
366 _token: &NamespaceToken,
367 edge_id: Uuid,
368 ) -> RuntimeResult<Option<Edge>> {
369 self.get_edge_by_id_inner(edge_id, true).await
370 }
371
372 async fn get_edge_by_id_inner(
373 &self,
374 edge_id: Uuid,
375 include_deleted: bool,
376 ) -> RuntimeResult<Option<Edge>> {
377 let (sql, label) = if include_deleted {
378 (
379 "SELECT namespace FROM graph_edges WHERE id = ?1 LIMIT 1",
380 "get_edge_including_deleted_namespace",
381 )
382 } else {
383 (
384 "SELECT namespace FROM graph_edges \
385 WHERE id = ?1 AND deleted_at IS NULL LIMIT 1",
386 "get_edge_namespace",
387 )
388 };
389 let mut reader = self.sql().reader().await?;
390 let record_ns = reader
391 .query_scalar(SqlStatement {
392 sql: sql.into(),
393 params: vec![SqlValue::Text(edge_id.to_string())],
394 label: Some(label.into()),
395 })
396 .await?;
397
398 let Some(SqlValue::Text(record_ns)) = record_ns else {
399 return Ok(None);
400 };
401 let record_tok = NamespaceToken::for_namespace(
403 khive_types::Namespace::parse(&record_ns)
404 .map_err(|e| RuntimeError::Internal(format!("edge namespace invalid: {e}")))?,
405 );
406 let graph = self.graph(&record_tok)?;
407 Ok(if include_deleted {
408 graph
409 .get_edge_including_deleted(LinkId::from(edge_id))
410 .await?
411 } else {
412 graph.get_edge(LinkId::from(edge_id)).await?
413 })
414 }
415
416 pub async fn get_edge_by_natural_key_including_deleted(
430 &self,
431 token: &NamespaceToken,
432 namespace: &str,
433 source_id: Uuid,
434 target_id: Uuid,
435 relation: EdgeRelation,
436 ) -> RuntimeResult<Option<Edge>> {
437 Ok(self
438 .graph(token)?
439 .get_edge_by_natural_key_including_deleted(namespace, source_id, target_id, relation)
440 .await?)
441 }
442
443 pub const EDGE_LIST_MAX_LIMIT: u32 = 1000;
448
449 pub async fn list_edges(
454 &self,
455 token: &NamespaceToken,
456 filter: crate::curation::EdgeListFilter,
457 limit: u32,
458 offset: u32,
459 ) -> RuntimeResult<Vec<Edge>> {
460 let limit = limit.min(Self::EDGE_LIST_MAX_LIMIT);
461 let visible = token.visible_namespaces();
462
463 if let [ns] = visible {
466 let temp = NamespaceToken::for_namespace(ns.clone());
467 let page = self
468 .graph(&temp)?
469 .query_edges(
470 filter.into(),
471 vec![SortOrder {
472 field: EdgeSortField::CreatedAt,
473 direction: khive_storage::types::SortDirection::Asc,
474 }],
475 PageRequest {
476 offset: offset.into(),
477 limit,
478 },
479 )
480 .await?;
481 return Ok(page.items);
482 }
483
484 let ns_strs: Vec<String> = visible.iter().map(|ns| ns.as_str().to_owned()).collect();
491 let sort = vec![SortOrder {
492 field: EdgeSortField::CreatedAt,
493 direction: khive_storage::types::SortDirection::Asc,
494 }];
495 let graph = self.graph(token)?;
496 match graph
497 .query_edges_in_namespaces(
498 &ns_strs,
499 filter.clone().into(),
500 sort.clone(),
501 PageRequest {
502 offset: offset.into(),
503 limit,
504 },
505 )
506 .await
507 {
508 Ok(page) => Ok(page.items),
509 Err(khive_storage::StorageError::Unsupported { operation, .. })
510 if operation == "query_edges_in_namespaces" =>
511 {
512 let fetch_limit = offset.saturating_add(limit);
525 let mut namespace_prefixes = Vec::new();
526 for ns in visible {
527 let temp = NamespaceToken::for_namespace(ns.clone());
528 let page = self
529 .graph(&temp)?
530 .query_edges(
531 filter.clone().into(),
532 sort.clone(),
533 PageRequest {
534 offset: 0,
535 limit: fetch_limit,
536 },
537 )
538 .await?;
539 namespace_prefixes.push(page.items);
540 }
541 Ok(Self::merge_paged_namespace_edges(
542 namespace_prefixes,
543 offset,
544 limit,
545 ))
546 }
547 Err(error) => Err(error.into()),
548 }
549 }
550
551 pub(super) fn merge_paged_namespace_edges(
566 namespace_prefixes: Vec<Vec<Edge>>,
567 offset: u32,
568 limit: u32,
569 ) -> Vec<Edge> {
570 let mut results: Vec<Edge> = namespace_prefixes.into_iter().flatten().collect();
571 results.sort_by_key(|e| (e.created_at, Uuid::from(e.id)));
572 let start = (offset as usize).min(results.len());
573 let end = (start + limit as usize).min(results.len());
574 results[start..end].to_vec()
575 }
576
577 pub async fn list_edges_after(
589 &self,
590 token: &NamespaceToken,
591 filter: crate::curation::EdgeListFilter,
592 after: Option<Uuid>,
593 limit: u32,
594 ) -> RuntimeResult<(Vec<Edge>, Option<Uuid>)> {
595 let limit = limit.clamp(1, Self::EDGE_LIST_MAX_LIMIT);
596 let visible = token.visible_namespaces();
597 let limit_usize = limit as usize;
598 let cursor_store = self.graph(token)?;
599 let after = match after {
600 Some(id) => {
601 let edge = self
602 .get_edge_including_deleted(token, id)
603 .await?
604 .ok_or_else(|| RuntimeError::NotFound(format!("edge cursor {id}")))?;
605 Self::ensure_namespace_visible(&edge.namespace, token)?;
606 let sequence = cursor_store.edge_sequence(id).await?.ok_or_else(|| {
607 RuntimeError::Internal(format!(
608 "edge cursor {id} has no insertion-sequence ledger row"
609 ))
610 })?;
611 Some(SeekCursor { sequence, id })
612 }
613 None => None,
614 };
615
616 if let [ns] = visible {
617 let temp = NamespaceToken::for_namespace(ns.clone());
618 let page = self
619 .graph(&temp)?
620 .query_edges_sequence_after(filter.into(), after, limit)
621 .await?;
622 return Ok((page.items, page.next_after.map(|cursor| cursor.id)));
623 }
624
625 let probe_limit = limit.saturating_add(1);
629 let mut results = Vec::new();
630 for ns in visible {
631 let temp = NamespaceToken::for_namespace(ns.clone());
632 let page = self
633 .graph(&temp)?
634 .query_edges_sequence_after(filter.clone().into(), after, probe_limit)
635 .await?;
636 results.extend(page.items);
637 }
638 let ids = results
639 .iter()
640 .map(|edge| Uuid::from(edge.id))
641 .collect::<Vec<_>>();
642 let sequences = cursor_store
643 .edge_sequences(&ids)
644 .await?
645 .into_iter()
646 .collect::<HashMap<_, _>>();
647 if let Some(missing) = ids.iter().find(|id| !sequences.contains_key(id)) {
648 return Err(RuntimeError::Internal(format!(
649 "edge {missing} has no insertion-sequence ledger row"
650 )));
651 }
652 results.sort_by_key(|edge| {
653 let id = Uuid::from(edge.id);
654 (sequences[&id], id)
655 });
656 results.dedup_by_key(|e| Uuid::from(e.id));
657 let has_more = results.len() > limit_usize;
658 if has_more {
659 results.truncate(limit_usize);
660 }
661 let next_after = if has_more {
662 results.last().map(|e| Uuid::from(e.id))
663 } else {
664 None
665 };
666 Ok((results, next_after))
667 }
668
669 pub async fn count_edges_by_relation(
673 &self,
674 token: &NamespaceToken,
675 ) -> RuntimeResult<std::collections::HashMap<String, u64>> {
676 let namespaces: Vec<String> = token
677 .visible_namespaces()
678 .iter()
679 .map(|namespace| namespace.as_str().to_owned())
680 .collect();
681 let graph = self.graph(token)?;
682 let counts = match graph
683 .count_edges_by_relation_in_namespaces(&namespaces)
684 .await
685 {
686 Ok(counts) => counts,
687 Err(khive_storage::StorageError::Unsupported { operation, .. })
688 if operation == "count_edges_by_relation_in_namespaces" =>
689 {
690 let mut totals = HashMap::new();
691 for namespace in token.visible_namespaces() {
692 let scoped = NamespaceToken::for_namespace(namespace.clone());
693 for (relation, count) in self.graph(&scoped)?.count_edges_by_relation().await? {
694 *totals.entry(relation).or_insert(0) += count;
695 }
696 }
697 return Ok(totals
698 .into_iter()
699 .map(|(relation, count)| (relation.to_string(), count))
700 .collect());
701 }
702 Err(error) => return Err(error.into()),
703 };
704 Ok(counts
705 .into_iter()
706 .map(|(relation, count)| (relation.to_string(), count))
707 .collect())
708 }
709
710 pub async fn count_edges_by_endpoint_base(
719 &self,
720 token: &NamespaceToken,
721 ) -> RuntimeResult<khive_storage::types::EdgeEndpointBaseCounts> {
722 use khive_storage::types::EdgeEndpointBaseCounts;
723
724 let namespaces: Vec<String> = token
725 .visible_namespaces()
726 .iter()
727 .map(|namespace| namespace.as_str().to_owned())
728 .collect();
729 let graph = self.graph(token)?;
730 match graph
731 .count_edges_by_endpoint_base_in_namespaces(&namespaces)
732 .await
733 {
734 Ok(counts) => Ok(counts),
735 Err(khive_storage::StorageError::Unsupported { operation, .. })
736 if operation == "count_edges_by_endpoint_base_in_namespaces"
737 || operation == "count_edges_by_endpoint_base" =>
738 {
739 let mut totals = EdgeEndpointBaseCounts::default();
740 for namespace in token.visible_namespaces() {
741 let scoped = NamespaceToken::for_namespace(namespace.clone());
742 let counts = self.graph(&scoped)?.count_edges_by_endpoint_base().await?;
743 totals.entity_entity =
744 totals.entity_entity.saturating_add(counts.entity_entity);
745 totals.entity_note = totals.entity_note.saturating_add(counts.entity_note);
746 totals.note_entity = totals.note_entity.saturating_add(counts.note_entity);
747 totals.note_note = totals.note_note.saturating_add(counts.note_note);
748 totals.unresolved = totals.unresolved.saturating_add(counts.unresolved);
749 }
750 Ok(totals)
751 }
752 Err(error) => Err(error.into()),
753 }
754 }
755
756 pub async fn edge_stats_counts(
766 &self,
767 token: &NamespaceToken,
768 ) -> RuntimeResult<super::EdgeStatsCounts> {
769 let namespaces: Vec<String> = token
770 .visible_namespaces()
771 .iter()
772 .map(|namespace| namespace.as_str().to_owned())
773 .collect();
774 let graph = self.graph(token)?;
775 match graph
776 .count_edges_by_relation_and_endpoint_base_in_namespaces(&namespaces)
777 .await
778 {
779 Ok(groups) => {
780 let mut counts = super::EdgeStatsCounts::default();
781 for (relation, by_base) in groups {
782 let relation_total = by_base.total();
783 counts.edges = counts.edges.saturating_add(relation_total);
784 let slot = counts
785 .edges_by_relation
786 .entry(relation.to_string())
787 .or_insert(0);
788 *slot = slot.saturating_add(relation_total);
789 let totals = &mut counts.edges_by_endpoint_base;
790 totals.entity_entity =
791 totals.entity_entity.saturating_add(by_base.entity_entity);
792 totals.entity_note = totals.entity_note.saturating_add(by_base.entity_note);
793 totals.note_entity = totals.note_entity.saturating_add(by_base.note_entity);
794 totals.note_note = totals.note_note.saturating_add(by_base.note_note);
795 totals.unresolved = totals.unresolved.saturating_add(by_base.unresolved);
796 }
797 Ok(counts)
798 }
799 Err(khive_storage::StorageError::Unsupported { operation, .. })
800 if operation == "count_edges_by_relation_and_endpoint_base_in_namespaces" =>
801 {
802 Ok(super::EdgeStatsCounts {
803 edges: self
804 .count_edges(token, crate::curation::EdgeListFilter::default())
805 .await?,
806 edges_by_relation: self.count_edges_by_relation(token).await?,
807 edges_by_endpoint_base: self.count_edges_by_endpoint_base(token).await?,
808 })
809 }
810 Err(error) => Err(error.into()),
811 }
812 }
813
814 pub async fn update_edge(
828 &self,
829 token: &NamespaceToken,
830 edge_id: Uuid,
831 patch: crate::curation::EdgePatch,
832 ) -> RuntimeResult<Edge> {
833 let graph_for_fetch = self.graph(token)?;
836 let mut edge = graph_for_fetch
837 .get_edge(LinkId::from(edge_id))
838 .await?
839 .ok_or_else(|| crate::RuntimeError::NotFound(format!("edge {edge_id}")))?;
840 let expected_updated_at = edge.updated_at;
841 let expected_deleted_at = edge.deleted_at;
842 #[cfg(test)]
843 crate::curation::race_seam::pause_after_read().await;
844
845 let record_ns: String = edge.namespace.clone();
850 let record_tok = token.with_namespace(
851 khive_types::Namespace::parse(&record_ns)
852 .map_err(|e| RuntimeError::Internal(format!("edge namespace invalid: {e}")))?,
853 );
854 let graph = self.graph(&record_tok)?;
855
856 let mut changed_fields: Vec<&'static str> = Vec::new();
857 if let Some(r) = patch.relation {
858 self.validate_edge_relation_endpoints(&record_tok, edge.source_id, edge.target_id, r)
861 .await?;
862 edge.relation = r;
863 changed_fields.push("relation");
864 }
865 if let Some(w) = patch.weight {
866 if !khive_types::validate_edge_weight(w) {
869 return Err(RuntimeError::InvalidInput(format!(
870 "edge weight must be a finite value in [0.0, 1.0]; got {w}"
871 )));
872 }
873 edge.weight = w;
874 changed_fields.push("weight");
875 }
876 if let Some(props) = patch.properties {
877 crate::secret_gate::reject_reserved_secret_gate_property(Some(&props))?;
878 edge.metadata = Self::merge_edge_properties(&edge.metadata, props);
879 }
880
881 let (canon_src, canon_tgt) =
891 canonical_edge_endpoints(edge.relation, edge.source_id, edge.target_id);
892
893 if edge.relation.is_symmetric() {
894 let outcome = graph
895 .update_symmetric_edge_if_unchanged(SymmetricEdgeUpdateRequest {
896 namespace: record_ns.clone(),
897 id: edge_id.into(),
898 source_id: canon_src,
899 target_id: canon_tgt,
900 relation: edge.relation,
901 weight: edge.weight,
902 metadata: edge.metadata.clone(),
903 expected_updated_at_micros: expected_updated_at.timestamp_micros(),
904 expected_deleted_at_micros: expected_deleted_at.map(|v| v.timestamp_micros()),
905 })
906 .await?;
907
908 match outcome {
909 SymmetricEdgeUpdateOutcome::Absorbed(sid) => {
910 let surviving_uuid = Uuid::parse_str(&sid).map_err(|e| {
917 RuntimeError::Internal(format!(
918 "update_edge: surviving id parse failed: {e}"
919 ))
920 })?;
921 edge = self
922 .get_edge_including_deleted(&record_tok, surviving_uuid)
923 .await?
924 .ok_or_else(|| {
925 RuntimeError::Internal(format!(
926 "update_edge: surviving canonical row {surviving_uuid} vanished after update"
927 ))
928 })?;
929 }
930 SymmetricEdgeUpdateOutcome::Updated => {
931 edge.source_id = canon_src;
933 edge.target_id = canon_tgt;
934 }
935 SymmetricEdgeUpdateOutcome::Stale => {
936 return Err(crate::curation::stale_edge_snapshot_error(edge_id));
937 }
938 }
939 } else {
940 let minimum_updated_at_micros = expected_updated_at
953 .timestamp_micros()
954 .checked_add(1)
955 .ok_or_else(|| {
956 RuntimeError::Internal(format!(
957 "edge {edge_id} updated_at is already at i64::MAX and cannot advance"
958 ))
959 })?;
960 let now_micros = chrono::Utc::now()
961 .timestamp_micros()
962 .max(minimum_updated_at_micros);
963 edge.updated_at =
964 chrono::DateTime::from_timestamp_micros(now_micros).ok_or_else(|| {
965 RuntimeError::Internal(format!(
966 "edge {edge_id}: computed updated_at {now_micros} is not a valid timestamp"
967 ))
968 })?;
969 let persisted = graph
970 .replace_edge_if_unchanged(edge.clone(), expected_updated_at, expected_deleted_at)
971 .await?;
972 if !persisted {
973 return Err(crate::curation::stale_edge_snapshot_error(edge_id));
974 }
975 }
976
977 let event_store = self.events(&record_tok)?;
979 let event = khive_storage::event::Event::new(
980 record_ns.clone(),
981 "update",
982 EventKind::EdgeUpdated,
983 SubstrateKind::Entity,
984 "",
985 )
986 .with_target(edge_id)
987 .with_payload(
988 serde_json::json!({"id": edge_id, "namespace": record_ns, "changed_fields": changed_fields}),
989 );
990 event_store.append_event(event).await.map_err(|e| {
991 RuntimeError::Internal(format!("update_edge: event store write failed: {e}"))
992 })?;
993
994 Ok(edge)
995 }
996
997 pub async fn delete_edge(
1008 &self,
1009 token: &NamespaceToken,
1010 edge_id: Uuid,
1011 hard: bool,
1012 ) -> RuntimeResult<bool> {
1013 let mode = if hard {
1014 DeleteMode::Hard
1015 } else {
1016 DeleteMode::Soft
1017 };
1018
1019 let edge = if hard {
1025 self.get_edge_including_deleted(token, edge_id).await?
1026 } else {
1027 self.get_edge(token, edge_id).await?
1028 };
1029 let Some(edge) = edge else {
1030 return Ok(false);
1031 };
1032
1033 let record_ns: String = edge.namespace.clone();
1035 let record_tok = token.with_namespace(
1036 khive_types::Namespace::parse(&record_ns)
1037 .map_err(|e| RuntimeError::Internal(format!("edge namespace invalid: {e}")))?,
1038 );
1039 let graph = self.graph(&record_tok)?;
1040 let actor = format!("{}:{}", token.actor().kind, token.actor().id);
1041
1042 let deleted = if hard {
1049 self.atomic_hard_delete_with_edge_purge(
1050 edge_hard_delete_statement(edge_id),
1051 edge_id,
1052 &record_ns,
1053 &actor,
1054 SubstrateKind::Entity,
1055 )
1056 .await?
1057 } else {
1058 graph.delete_edge(LinkId::from(edge_id), mode).await?
1059 };
1060 if deleted {
1061 let event_store = self.events(&record_tok)?;
1063 let event = khive_storage::event::Event::new(
1064 record_ns.clone(),
1065 "delete",
1066 EventKind::EdgeDeleted,
1067 SubstrateKind::Entity,
1068 "",
1069 )
1070 .with_target(edge_id)
1071 .with_payload(serde_json::json!({"id": edge_id, "namespace": record_ns, "hard": hard}));
1072 event_store.append_event(event).await.map_err(|e| {
1073 RuntimeError::Internal(format!("delete_edge: event store write failed: {e}"))
1074 })?;
1075 }
1076 Ok(deleted)
1077 }
1078
1079 pub async fn count_edges(
1081 &self,
1082 token: &NamespaceToken,
1083 filter: crate::curation::EdgeListFilter,
1084 ) -> RuntimeResult<u64> {
1085 let namespaces: Vec<String> = token
1086 .visible_namespaces()
1087 .iter()
1088 .map(|namespace| namespace.as_str().to_owned())
1089 .collect();
1090 let graph = self.graph(token)?;
1091 match graph
1092 .count_edges_in_namespaces(&namespaces, filter.clone().into())
1093 .await
1094 {
1095 Ok(count) => Ok(count),
1096 Err(khive_storage::StorageError::Unsupported { operation, .. })
1097 if operation == "count_edges_in_namespaces" =>
1098 {
1099 let mut total = 0;
1100 for namespace in token.visible_namespaces() {
1101 let scoped = NamespaceToken::for_namespace(namespace.clone());
1102 total += self
1103 .graph(&scoped)?
1104 .count_edges(filter.clone().into())
1105 .await?;
1106 }
1107 Ok(total)
1108 }
1109 Err(error) => Err(error.into()),
1110 }
1111 }
1112}