second-brain-api 0.13.5

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

use axum::Json;
use axum::extract::rejection::QueryRejection;
use axum::extract::{Query, State};
use axum::response::IntoResponse;
use chrono::Utc;
use second_brain_core::digest::{DEFAULT_WINDOW, Digest, Window};
use serde::Deserialize;

use super::project_names::refuse_unknown_project;
use super::{bad_request, internal_error};
use crate::AppState;

#[derive(Deserialize)]
pub(super) struct DigestQuery {
    since: Option<String>,
    project: Option<String>,
}

fn read_digest(
    state: &AppState,
    window: Window,
    project: Option<&str>,
) -> anyhow::Result<Result<Digest, String>> {
    if let Some(project) = project
        && let Some(refusal) = refuse_unknown_project(&state.sqlite, project)?
    {
        return Ok(Err(refusal));
    }
    Ok(Ok(Digest::read(&state.sqlite, window, project)?))
}

pub(super) async fn digest(
    State(state): State<Arc<AppState>>,
    query: Result<Query<DigestQuery>, QueryRejection>,
) -> axum::response::Response {
    let request = query
        .map_err(|rejection| rejection.body_text())
        .and_then(|Query(q)| {
            let since = q.since.as_deref().unwrap_or(DEFAULT_WINDOW);
            Ok((Window::parse(since, Utc::now())?, q.project))
        });
    let (window, project) = match request {
        Ok(request) => request,
        Err(message) => return bad_request(message),
    };
    let result =
        tokio::task::spawn_blocking(move || read_digest(&state, window, project.as_deref())).await;
    match result {
        Ok(Ok(Ok(digest))) => Json(digest).into_response(),
        Ok(Ok(Err(message))) => bad_request(message),
        Ok(Err(e)) => internal_error(e),
        Err(e) => internal_error(e),
    }
}