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>,
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 {
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 || {
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(),
}
}