smokesignal / src / http / handle_xrpc_get_rsvp.rs

use atproto_record::aturi::ATURI;
use axum::{
    extract::{Query, State},
    response::{IntoResponse, Json},
};
use http::StatusCode;
use serde::{Deserialize, Serialize};
use std::str::FromStr;

use crate::http::context::WebContext;
use crate::storage::event::rsvp_get_by_event_and_did;

#[derive(Debug, Deserialize)]
pub struct GetRsvpParams {
    /// AT-URI of the event
    event: String,
    /// DID of the identity to get the RSVP for
    identity: String,
}

#[derive(Debug, Serialize)]
pub struct GetRsvpResponse {
    /// AT-URI of the RSVP record
    uri: String,
    /// CID of the RSVP record
    cid: String,
    /// The RSVP record
    record: serde_json::Value,
}

#[derive(Debug, Serialize)]
struct GetRsvpError {
    error: String,
    message: String,
}

impl GetRsvpError {
    fn invalid_request(message: &str) -> Self {
        Self {
            error: "InvalidRequest".to_string(),
            message: message.to_string(),
        }
    }

    fn not_found(message: &str) -> Self {
        Self {
            error: "NotFound".to_string(),
            message: message.to_string(),
        }
    }

    fn internal_error(message: &str) -> Self {
        Self {
            error: "InternalServerError".to_string(),
            message: message.to_string(),
        }
    }
}

/// XRPC query endpoint for getting an RSVP record.
///
/// This endpoint retrieves an RSVP record for a specific identity and event.
/// No authentication is required as RSVP data is public.
pub(crate) async fn handle_xrpc_get_rsvp(
    State(web_context): State<WebContext>,
    Query(params): Query<GetRsvpParams>,
) -> impl IntoResponse {
    // Validate event AT-URI format
    if ATURI::from_str(&params.event).is_err() {
        return (
            StatusCode::BAD_REQUEST,
            Json(GetRsvpError::invalid_request("Invalid event AT-URI format")),
        )
            .into_response();
    }

    let identity = match web_context
        .identity_resolver
        .resolve(&params.identity)
        .await
    {
        Ok(value) => value,
        Err(_) => {
            return (
                StatusCode::BAD_REQUEST,
                Json(GetRsvpError::invalid_request("Invalid identity DID format")),
            )
                .into_response();
        }
    };

    // Fetch the RSVP
    let rsvp = match rsvp_get_by_event_and_did(&web_context.pool, &params.event, &identity.id).await
    {
        Ok(Some(rsvp)) => rsvp,
        Ok(None) => {
            return (
                StatusCode::NOT_FOUND,
                Json(GetRsvpError::not_found("RSVP not found")),
            )
                .into_response();
        }
        Err(err) => {
            tracing::error!(
                ?err,
                event = %params.event,
                identity = %params.identity,
                "Failed to fetch RSVP"
            );
            return (
                StatusCode::INTERNAL_SERVER_ERROR,
                Json(GetRsvpError::internal_error("Failed to fetch RSVP")),
            )
                .into_response();
        }
    };

    let response = GetRsvpResponse {
        uri: rsvp.aturi,
        cid: rsvp.cid,
        record: rsvp.record.0,
    };

    (StatusCode::OK, Json(response)).into_response()
}