second-brain-api 0.12.0

HTTP API server for second-brain: REST endpoints for recall, remember, and ingest
Documentation
use std::sync::Arc;

use axum::Json;
use axum::extract::State;
use axum::http::StatusCode;
use axum::response::IntoResponse;
use second_brain_core::schema::SyncOp;
use second_brain_sync::protocol::{SyncHeader, VersionError, check_store_header, store_header};
use serde::{Deserialize, Serialize};

use super::internal_error;
use crate::AppState;

fn sync_error(e: anyhow::Error) -> axum::response::Response {
    if e.downcast_ref::<VersionError>().is_none() {
        return internal_error(e);
    }
    (
        StatusCode::CONFLICT,
        Json(serde_json::json!({"error": e.to_string()})),
    )
        .into_response()
}

pub(super) async fn sync_version(State(state): State<Arc<AppState>>) -> impl IntoResponse {
    let sqlite = state.sqlite.clone();
    match tokio::task::spawn_blocking(move || store_header(&sqlite)).await {
        Ok(Ok(header)) => Json(header).into_response(),
        Ok(Err(e)) => sync_error(e),
        Err(e) => internal_error(e),
    }
}

#[derive(Deserialize)]
pub(super) struct SyncExportRequest {
    after_seq: Option<u64>,
    limit: Option<usize>,
    /// The calling `sb`'s own versions; absent from 0.10.0 and older.
    header: Option<SyncHeader>,
}

#[derive(Serialize)]
struct SyncExportResponse {
    records: Vec<serde_json::Value>,
    max_seq: u64,
}

pub(super) async fn sync_export(
    State(state): State<Arc<AppState>>,
    Json(req): Json<SyncExportRequest>,
) -> impl IntoResponse {
    let after_seq = req.after_seq.unwrap_or(0);
    let limit = req.limit;
    let store = state.store.clone();
    let sqlite = state.sqlite.clone();

    let result = tokio::task::spawn_blocking(move || -> anyhow::Result<SyncExportResponse> {
        check_store_header(&sqlite, req.header, "the calling sb")?;
        if let Some(limit) = limit {
            let (records, max_seq) =
                second_brain_sync::export::export_page(store.as_ref(), after_seq, limit)?;
            Ok(SyncExportResponse { records, max_seq })
        } else {
            let mut buf = Vec::new();
            let max_seq =
                second_brain_sync::export::export_changes(store.as_ref(), after_seq, &mut buf)?;
            let jsonl = String::from_utf8(buf)?;
            let records: Vec<serde_json::Value> = jsonl
                .lines()
                .filter(|l| !l.trim().is_empty())
                .filter_map(|l| serde_json::from_str(l).ok())
                .collect();
            Ok(SyncExportResponse { records, max_seq })
        }
    })
    .await;

    match result {
        Ok(Ok(resp)) => Json(resp).into_response(),
        Ok(Err(e)) => sync_error(e),
        Err(e) => (
            StatusCode::INTERNAL_SERVER_ERROR,
            Json(serde_json::json!({"error": e.to_string()})),
        )
            .into_response(),
    }
}

#[derive(Deserialize)]
pub(super) struct SyncImportRequest {
    /// The header of the stream the records came from, not the caller's own.
    header: Option<SyncHeader>,
    records: Vec<serde_json::Value>,
}

#[derive(Serialize)]
struct SyncImportResponse {
    created: u64,
    updated: u64,
    deleted: u64,
    skipped: u64,
    #[serde(default)]
    skipped_by_reason: std::collections::BTreeMap<String, u64>,
    errors: u64,
    max_seq: u64,
}

pub(super) async fn sync_import(
    State(state): State<Arc<AppState>>,
    Json(req): Json<SyncImportRequest>,
) -> impl IntoResponse {
    let store = state.store.clone();
    let sqlite = state.sqlite.clone();

    let result = tokio::task::spawn_blocking(move || -> anyhow::Result<SyncImportResponse> {
        check_store_header(&sqlite, req.header, "the sender")?;
        let (stats, watermark) =
            second_brain_sync::import::import_values(store.as_ref(), &req.records)?;
        Ok(SyncImportResponse {
            created: stats.created,
            updated: stats.updated,
            deleted: stats.deleted,
            skipped: stats.skipped,
            skipped_by_reason: stats.skipped_by_reason,
            errors: stats.errors,
            max_seq: watermark,
        })
    })
    .await;

    match result {
        Ok(Ok(resp)) => Json(resp).into_response(),
        Ok(Err(e)) => sync_error(e),
        Err(e) => (
            StatusCode::INTERNAL_SERVER_ERROR,
            Json(serde_json::json!({"error": e.to_string()})),
        )
            .into_response(),
    }
}

#[derive(Serialize)]
struct SyncPeerStatus {
    peer_id: String,
    last_seq: u64,
    last_sync_at: String,
}

pub(super) async fn sync_status(State(state): State<Arc<AppState>>) -> impl IntoResponse {
    let store = state.store.clone();

    let result = tokio::task::spawn_blocking(move || store.get_all_sync_states()).await;

    match result {
        Ok(Ok(states)) => {
            let peers: Vec<SyncPeerStatus> = states
                .into_iter()
                .map(|s| SyncPeerStatus {
                    peer_id: s.peer_id,
                    last_seq: s.last_seq,
                    last_sync_at: s.last_sync_at.to_rfc3339(),
                })
                .collect();
            Json(serde_json::json!({"peers": peers})).into_response()
        }
        Ok(Err(e)) => (
            StatusCode::INTERNAL_SERVER_ERROR,
            Json(serde_json::json!({"error": e.to_string()})),
        )
            .into_response(),
        Err(e) => (
            StatusCode::INTERNAL_SERVER_ERROR,
            Json(serde_json::json!({"error": e.to_string()})),
        )
            .into_response(),
    }
}

pub(super) async fn sync_prune_relations(State(state): State<Arc<AppState>>) -> impl IntoResponse {
    let store = state.store.clone();

    let result = tokio::task::spawn_blocking(move || store.prune_dangling_relations()).await;

    match result {
        Ok(Ok(pruned)) => Json(serde_json::json!({"pruned": pruned})).into_response(),
        Ok(Err(e)) => (
            StatusCode::INTERNAL_SERVER_ERROR,
            Json(serde_json::json!({"error": e.to_string()})),
        )
            .into_response(),
        Err(e) => (
            StatusCode::INTERNAL_SERVER_ERROR,
            Json(serde_json::json!({"error": e.to_string()})),
        )
            .into_response(),
    }
}

#[derive(Deserialize)]
pub(super) struct SyncCompactRequest {
    ops: Vec<SyncOp>,
    #[serde(default = "default_true")]
    dry_run: bool,
}

fn default_true() -> bool {
    true
}

pub(super) async fn sync_compact(
    State(state): State<Arc<AppState>>,
    Json(req): Json<SyncCompactRequest>,
) -> impl IntoResponse {
    let store = state.store.clone();

    let result =
        tokio::task::spawn_blocking(move || store.compact_sync_log(&req.ops, req.dry_run)).await;

    match result {
        Ok(Ok(stats)) => Json(serde_json::json!({
            "groups_with_duplicates": stats.groups_with_duplicates,
            "rows_deleted": stats.rows_deleted,
            "max_local_seq_before": stats.max_local_seq_before,
            "max_local_seq_after": stats.max_local_seq_after,
        }))
        .into_response(),
        Ok(Err(e)) => (
            StatusCode::INTERNAL_SERVER_ERROR,
            Json(serde_json::json!({"error": e.to_string()})),
        )
            .into_response(),
        Err(e) => (
            StatusCode::INTERNAL_SERVER_ERROR,
            Json(serde_json::json!({"error": e.to_string()})),
        )
            .into_response(),
    }
}

pub(super) async fn sync_backfill(State(state): State<Arc<AppState>>) -> impl IntoResponse {
    let store = state.store.clone();

    let result = tokio::task::spawn_blocking(move || {
        // Creates and deletes are backfilled together: seeding a peer with only the
        // surviving memories would resurrect everything this store has deleted.
        let created = store.backfill_sync_log()?;
        let deleted = store.backfill_tombstones()?;
        anyhow::Ok((created, deleted))
    })
    .await;

    match result {
        Ok(Ok((count, tombstones))) => {
            Json(serde_json::json!({"backfilled": count, "tombstones_backfilled": tombstones}))
                .into_response()
        }
        Ok(Err(e)) => (
            StatusCode::INTERNAL_SERVER_ERROR,
            Json(serde_json::json!({"error": e.to_string()})),
        )
            .into_response(),
        Err(e) => (
            StatusCode::INTERNAL_SERVER_ERROR,
            Json(serde_json::json!({"error": e.to_string()})),
        )
            .into_response(),
    }
}

#[derive(Deserialize)]
pub(super) struct SetSyncStateRequest {
    peer_id: String,
    last_seq: u64,
}

pub(super) async fn set_sync_state(
    State(state): State<Arc<AppState>>,
    Json(req): Json<SetSyncStateRequest>,
) -> impl IntoResponse {
    let store = state.store.clone();
    let peer_id = req.peer_id;
    let last_seq = req.last_seq;

    let result = tokio::task::spawn_blocking(move || {
        use second_brain_core::schema::SyncState;
        store.set_sync_state(&SyncState {
            peer_id,
            last_seq,
            last_sync_at: chrono::Utc::now(),
        })
    })
    .await;

    match result {
        Ok(Ok(_)) => StatusCode::OK.into_response(),
        Ok(Err(e)) => (
            StatusCode::INTERNAL_SERVER_ERROR,
            Json(serde_json::json!({"error": e.to_string()})),
        )
            .into_response(),
        Err(e) => (
            StatusCode::INTERNAL_SERVER_ERROR,
            Json(serde_json::json!({"error": e.to_string()})),
        )
            .into_response(),
    }
}