second-brain-api 0.13.4

HTTP API server for second-brain: REST endpoints for recall, remember, and ingest
Documentation
mod common;

use axum::http::StatusCode;
use tower::ServiceExt;
use uuid::Uuid;

use common::{app_with_store, delete, get, json_body};
use second_brain_core::schema::{Memory, MemoryType, Tier};
use second_brain_core::store::Store;

fn stored(store: &second_brain_core::sqlite_store::SqliteStore, content: &str) -> Uuid {
    let m = Memory::new(
        content.to_string(),
        MemoryType::Semantic,
        "mcp-direct".to_string(),
        String::new(),
    );
    store.store_memory(&m).unwrap();
    m.id
}

#[tokio::test]
async fn forget_retires_by_default_and_records_the_reason() {
    let (app, store) = app_with_store();
    let id = stored(&store, "the office moved to level 3");

    let response = app
        .clone()
        .oneshot(delete(&format!("/v1/memory/{id}?reason=moved%20again")))
        .await
        .unwrap();
    assert_eq!(response.status(), StatusCode::OK);
    let body = json_body(response).await;
    assert_eq!(body["action"], "retired");

    let kept = store.get_memory(id).unwrap().unwrap();
    assert_eq!(kept.tier, Tier::Archived);
    assert_eq!(kept.retired_reason.as_deref(), Some("moved again"));
    assert!(!store.tombstone_exists(id).unwrap());

    let response = app
        .clone()
        .oneshot(get(&format!("/v1/memory/{id}")))
        .await
        .unwrap();
    assert_eq!(response.status(), StatusCode::OK);
    let body = json_body(response).await;
    assert_eq!(body["tier"], "archived");
    assert_eq!(body["retired_reason"], "moved again");

    let response = app
        .clone()
        .oneshot(delete(&format!("/v1/memory/{id}")))
        .await
        .unwrap();
    assert_eq!(response.status(), StatusCode::OK);
    assert_eq!(json_body(response).await["action"], "already_retired");
}

#[tokio::test]
async fn forget_with_hard_deletes_the_row() {
    let (app, store) = app_with_store();
    let id = stored(&store, "a secret pasted by mistake");

    let response = app
        .clone()
        .oneshot(delete(&format!("/v1/memory/{id}?hard=true")))
        .await
        .unwrap();
    assert_eq!(response.status(), StatusCode::OK);
    assert_eq!(json_body(response).await["action"], "deleted");
    assert!(store.get_memory(id).unwrap().is_none());
    assert!(store.tombstone_exists(id).unwrap());
}

#[tokio::test]
async fn forget_of_an_unknown_id_is_404_and_leaves_no_trace() {
    let (app, store) = app_with_store();
    for uri in ["", "?hard=true"] {
        let id = Uuid::new_v4();
        let response = app
            .clone()
            .oneshot(delete(&format!("/v1/memory/{id}{uri}")))
            .await
            .unwrap();
        assert_eq!(response.status(), StatusCode::NOT_FOUND, "{uri}");
        assert!(!store.tombstone_exists(id).unwrap());
    }
    assert_eq!(store.max_sync_seq().unwrap(), 0);
}

#[tokio::test]
async fn get_of_a_superseded_memory_names_its_replacement() {
    let (app, store) = app_with_store();
    let old = stored(&store, "the office is on level 2");
    let new = stored(&store, "the office is on level 3");
    store.supersede_memory(old, new).unwrap();

    let body = json_body(
        app.clone()
            .oneshot(get(&format!("/v1/memory/{old}")))
            .await
            .unwrap(),
    )
    .await;
    assert_eq!(body["tier"], "hot");
    assert_eq!(body["superseded_by"], new.to_string());
    assert!(body.get("retired_reason").is_none());

    let body = json_body(
        app.oneshot(get(&format!("/v1/memory/{new}")))
            .await
            .unwrap(),
    )
    .await;
    assert!(body.get("superseded_by").is_none());
}