khive_runtime/streams/
truncate.rs1use khive_storage::{SqlStatement, SqlValue, StorageError};
3use serde_json::{json, Value};
4use uuid::Uuid;
5
6use super::{stream_position_statement, validate_stream};
7use crate::atomic_prepare::{
8 apply_post_commit_effects_with_report, note_delete_plan, push_index_purge_for_tables,
9 vector_table_names, vector_tables_in_writer,
10};
11use crate::atomic_runner::{
12 apply_plan_preserving_storage, run_prepared_atomic_unit, PlanExecutionFailure,
13 PreparedAtomicError, PreparedAtomicOp, PreparedAtomicOutcome,
14};
15use crate::{KhiveRuntime, NamespaceToken, RuntimeError, RuntimeResult};
16
17fn refused(error: RuntimeError) -> PreparedAtomicError<RuntimeError> {
18 PreparedAtomicError::Refused {
19 message: error.to_string(),
20 failure: error,
21 }
22}
23
24fn invalid_state(error: impl std::fmt::Display) -> PreparedAtomicError<RuntimeError> {
25 refused(RuntimeError::Internal(format!(
26 "stream truncation: {error}"
27 )))
28}
29
30impl KhiveRuntime {
31 pub async fn stream_truncate(
34 &self,
35 token: &NamespaceToken,
36 stream: &str,
37 before_seq: i64,
38 ) -> RuntimeResult<Value> {
39 validate_stream(stream)?;
40 self.notes(token)?;
42 self.graph(token)?;
43 self.text_for_notes(token)?;
44 self.events(token)?;
45 let vector_candidates = vector_table_names(self);
46 let applying_token = token.clone();
47 let stream = stream.to_owned();
48 let op: PreparedAtomicOp<Value, RuntimeError> = Box::new(move |writer| {
49 Box::pin(async move {
50 let namespace = applying_token.namespace().as_str();
51 let position = writer
52 .query_row(stream_position_statement(namespace, &stream))
53 .await?
54 .ok_or_else(|| invalid_state("missing stream position"))?;
55 let head = position.i64("head_seq").map_err(invalid_state)?;
56 let floor = position.i64("floor_seq").map_err(invalid_state)?;
57 let next = head
58 .checked_add(1)
59 .ok_or_else(|| invalid_state("unrepresentable stream floor"))?;
60 let before = before_seq.min(next);
61 if before <= floor {
62 return Ok((
63 json!({"removed": 0, "floor_seq": floor, "head_seq": head}),
64 vec![],
65 ));
66 }
67 let prefix_params = vec![
68 SqlValue::Text(namespace.into()),
69 SqlValue::Text(stream.clone()),
70 SqlValue::Integer(before),
71 ];
72 let rows = writer
73 .query_all(SqlStatement::new(
74 "SELECT n.id,n.kind FROM note_streams s JOIN notes n ON n.id=s.note_id AND n.namespace=s.namespace \
75 WHERE s.namespace=?1 AND s.stream=?2 AND s.seq<?3 ORDER BY s.seq",
76 prefix_params.clone(),
77 ).labelled("stream-truncate-members"))
78 .await?;
79 let tables = vector_tables_in_writer(writer, &vector_candidates).await?;
80 let permit = writer
81 .execute(SqlStatement::new(
82 "INSERT INTO note_stream_truncations(namespace,stream,before_seq) VALUES (?1,?2,?3)",
83 prefix_params.clone(),
84 ).labelled("stream-truncate-permit"))
85 .await?;
86 if permit != 1 {
87 return Err(invalid_state("truncation permit was not inserted"));
88 }
89 let removed = writer
90 .execute(
91 SqlStatement::new(
92 "DELETE FROM note_streams WHERE namespace=?1 AND stream=?2 AND seq<?3",
93 prefix_params.clone(),
94 )
95 .labelled("stream-truncate-ledger"),
96 )
97 .await?;
98 if removed != rows.len() as u64 {
99 return Err(invalid_state("ledger prefix has missing note records"));
100 }
101 let mut effects = Vec::new();
102 for row in rows {
103 let id = Uuid::parse_str(row.text("id").map_err(invalid_state)?)
104 .map_err(invalid_state)?;
105 let kind = row.text("kind").map_err(invalid_state)?;
106 let mut indexes = Vec::new();
107 push_index_purge_for_tables(
108 &mut indexes,
109 "fts_notes",
110 namespace,
111 id,
112 "stream-truncate-note",
113 &tables,
114 );
115 let plan =
116 note_delete_plan(&applying_token, id, namespace, kind, true, indexes)
117 .map_err(refused)?;
118 match apply_plan_preserving_storage(writer, &plan, false).await {
119 Ok(applied) => effects.extend(applied.effect),
120 Err(PlanExecutionFailure::Storage { source, .. }) => {
121 return Err(PreparedAtomicError::Storage(source));
122 }
123 Err(PlanExecutionFailure::Operation(failure)) => {
124 return Err(invalid_state(format!(
125 "note deletion refused: {failure:?}"
126 )));
127 }
128 }
129 }
130 writer
131 .execute(SqlStatement::new(
132 "INSERT INTO note_stream_floors(namespace,stream,floor_seq) VALUES (?1,?2,?3) \
133 ON CONFLICT(namespace,stream) DO UPDATE SET floor_seq=excluded.floor_seq",
134 prefix_params,
135 ).labelled("stream-truncate-floor"))
136 .await?;
137 let cleared = writer
138 .execute(
139 SqlStatement::new(
140 "DELETE FROM note_stream_truncations WHERE namespace=?1 AND stream=?2",
141 vec![
142 SqlValue::Text(namespace.into()),
143 SqlValue::Text(stream.clone()),
144 ],
145 )
146 .labelled("stream-truncate-clear-permit"),
147 )
148 .await?;
149 if cleared != 1 {
150 return Err(PreparedAtomicError::Storage(StorageError::Internal(
151 "stream truncation permit disappeared".into(),
152 )));
153 }
154 Ok((
155 json!({"removed": removed, "floor_seq": before, "head_seq": head}),
156 effects,
157 ))
158 })
159 });
160 let access = self.sql();
161 match run_prepared_atomic_unit(access.as_ref(), op).await? {
162 PreparedAtomicOutcome::RolledBack(error) => Err(error),
163 PreparedAtomicOutcome::Committed { value, post_commit } => {
164 apply_post_commit_effects_with_report(self, token, post_commit).await?;
165 Ok(value)
166 }
167 }
168 }
169}