Skip to main content

khive_runtime/streams/
truncate.rs

1//! Prefix removal uses one SQL-only writer and the canonical note-delete plan.
2use 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    /// Remove entries below the clipped prefix bound, retaining a monotonic head.
32    /// All ledger, note, index and floor writes share the same transaction.
33    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        // Open stores before entering the suspend-free applying transaction.
41        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}