appstruct-codegen 0.2.0

Deterministic Rust, SQL, OpenAPI, TypeScript, and React generation for AppStruct
Documentation
use super::admin::{AdminListMeta, admin_pagination, require_admin};
use super::config;
use crate::{ApiError, AppState};
use axum::extract::{Path, Query, State};
use axum::http::HeaderMap;
use axum::routing::get;
use axum::{Json, Router};
use sqlx::Row as _;
use crate::database::{DatabaseExecutor,  Sql};
use serde::{Deserialize, Serialize};

pub(super) fn router() -> Router<AppState> {
    Router::new()
        .route("/api/admin/mail", get(list_mail_deliveries))
        .route("/api/admin/mail/{id}", get(get_mail_delivery))
        .route("/api/admin/files", get(list_files))
        .route("/api/admin/files/{id}", get(get_file))
}

#[derive(Deserialize)]
struct StorageQuery {
    search: Option<String>,
    page: Option<u64>,
    page_size: Option<u64>,
}

#[derive(Serialize)]
struct AdminMailSummary {
    id: uuid::Uuid,
    provider: String,
    template: String,
    sender: String,
    recipient: String,
    subject: String,
    tenant_id: Option<uuid::Uuid>,
    created_at: chrono::DateTime<chrono::Utc>,
}

#[derive(Serialize)]
struct AdminMailDelivery {
    #[serde(flatten)]
    summary: AdminMailSummary,
    text_body: String,
    html_body: Option<String>,
}

#[derive(Serialize)]
struct AdminMailList {
    data: Vec<AdminMailSummary>,
    meta: AdminListMeta,
}

#[derive(Serialize)]
struct AdminFile {
    id: uuid::Uuid,
    object_key: String,
    original_name: String,
    content_type: String,
    size: u64,
    checksum: String,
    tenant_id: Option<uuid::Uuid>,
    created_at: chrono::DateTime<chrono::Utc>,
}

#[derive(Serialize)]
struct AdminFileList {
    data: Vec<AdminFile>,
    meta: AdminListMeta,
    total_bytes: u64,
}

async fn list_mail_deliveries(
    State(state): State<AppState>, headers: HeaderMap, Query(input): Query<StorageQuery>,
) -> Result<Json<AdminMailList>, ApiError> {
    require_admin(&state, &headers).await?;
    ensure_enabled(config::MAIL_ENABLED)?;
    let (page, page_size, offset) = admin_pagination(input.page, input.page_size)?;
    let search = normalized_search(input.search)?;
    let filter = "($1::text IS NULL OR recipient ILIKE '%' || $1 || '%' OR subject ILIKE '%' || $1 || '%' OR sender ILIKE '%' || $1 || '%' OR template ILIKE '%' || $1 || '%' OR provider ILIKE '%' || $1 || '%')";
    let count_sql = format!(
        "SELECT COUNT(*) AS total FROM \"_appstruct_mail_deliveries\" WHERE {filter}"
    );
    let total = query_i64(&state, &count_sql, search.clone()).await?;
    let list_sql = format!(
        "SELECT id, provider, template, sender, recipient, subject, tenant_id, created_at FROM \"_appstruct_mail_deliveries\" WHERE {filter} ORDER BY created_at DESC, id DESC LIMIT $2 OFFSET $3"
    );
    let rows = state.database.fetch_all(Sql::bind(list_sql,
        [
            search.into(),
            i64::try_from(page_size).unwrap_or(100).into(),
            i64::try_from(offset).unwrap_or(i64::MAX).into(),
        ],
    )).await?;
    let data = rows.into_iter().map(mail_summary_from_row).collect::<Result<Vec<_>, _>>()?;
    Ok(Json(AdminMailList {
        data,
        meta: AdminListMeta { page, page_size, total: total.try_into().unwrap_or(0) },
    }))
}

async fn get_mail_delivery(
    State(state): State<AppState>, headers: HeaderMap, Path(id): Path<String>,
) -> Result<Json<AdminMailDelivery>, ApiError> {
    require_admin(&state, &headers).await?;
    ensure_enabled(config::MAIL_ENABLED)?;
    let id = uuid::Uuid::parse_str(&id).map_err(|_| ApiError::InvalidId)?;
    let row = state.database.fetch_optional(Sql::bind("SELECT id, provider, template, sender, recipient, subject, tenant_id, created_at, text_body, html_body FROM \"_appstruct_mail_deliveries\" WHERE id = $1",
        [id.into()],
    )).await?.ok_or(ApiError::NotFound)?;
    let text_body = row.try_get("text_body")?;
    let html_body = row.try_get("html_body")?;
    Ok(Json(AdminMailDelivery {
        summary: mail_summary_from_row(row)?, text_body, html_body,
    }))
}

async fn list_files(
    State(state): State<AppState>, headers: HeaderMap, Query(input): Query<StorageQuery>,
) -> Result<Json<AdminFileList>, ApiError> {
    require_admin(&state, &headers).await?;
    ensure_enabled(config::FILE_ENABLED)?;
    let (page, page_size, offset) = admin_pagination(input.page, input.page_size)?;
    let search = normalized_search(input.search)?;
    let filter = "($1::text IS NULL OR object_key ILIKE '%' || $1 || '%' OR original_name ILIKE '%' || $1 || '%' OR content_type ILIKE '%' || $1 || '%' OR checksum ILIKE '%' || $1 || '%')";
    let totals_sql = format!(
        "SELECT COUNT(*) AS total, COALESCE(SUM(size), 0)::bigint AS total_bytes FROM \"_appstruct_files\" WHERE {filter}"
    );
    let totals = state.database.fetch_optional(Sql::bind(totals_sql, [search.clone().into()],
    )).await?.ok_or(ApiError::Internal)?;
    let total: i64 = totals.try_get("total")?;
    let total_bytes: i64 = totals.try_get("total_bytes")?;
    let list_sql = format!(
        "SELECT id, object_key, original_name, content_type, size, checksum, tenant_id, created_at FROM \"_appstruct_files\" WHERE {filter} ORDER BY created_at DESC, id DESC LIMIT $2 OFFSET $3"
    );
    let rows = state.database.fetch_all(Sql::bind(list_sql,
        [
            search.into(),
            i64::try_from(page_size).unwrap_or(100).into(),
            i64::try_from(offset).unwrap_or(i64::MAX).into(),
        ],
    )).await?;
    let data = rows.into_iter().map(file_from_row).collect::<Result<Vec<_>, _>>()?;
    Ok(Json(AdminFileList {
        data,
        meta: AdminListMeta { page, page_size, total: total.try_into().unwrap_or(0) },
        total_bytes: total_bytes.try_into().unwrap_or(0),
    }))
}

async fn get_file(
    State(state): State<AppState>, headers: HeaderMap, Path(id): Path<String>,
) -> Result<Json<AdminFile>, ApiError> {
    require_admin(&state, &headers).await?;
    ensure_enabled(config::FILE_ENABLED)?;
    let id = uuid::Uuid::parse_str(&id).map_err(|_| ApiError::InvalidId)?;
    let row = state.database.fetch_optional(Sql::bind("SELECT id, object_key, original_name, content_type, size, checksum, tenant_id, created_at FROM \"_appstruct_files\" WHERE id = $1",
        [id.into()],
    )).await?.ok_or(ApiError::NotFound)?;
    Ok(Json(file_from_row(row)?))
}

fn normalized_search(search: Option<String>) -> Result<Option<String>, ApiError> {
    let search = search.map(|value| value.trim().to_owned()).filter(|value| !value.is_empty());
    if search.as_ref().is_some_and(|value| value.len() > 200) {
        return Err(ApiError::InvalidQuery("search must not exceed 200 bytes".to_owned()));
    }
    Ok(search)
}

fn ensure_enabled(enabled: bool) -> Result<(), ApiError> {
    if enabled { Ok(()) } else { Err(ApiError::NotFound) }
}

async fn query_i64(
    state: &AppState, sql: &str, value: Option<String>,
) -> Result<i64, ApiError> {
    let row = state.database.fetch_optional(Sql::bind(sql.to_owned(), [value.into()],
    )).await?.ok_or(ApiError::Internal)?;
    Ok(row.try_get("total")?)
}

fn mail_summary_from_row(row: crate::database::PgRow) -> Result<AdminMailSummary, sqlx::Error> {
    Ok(AdminMailSummary {
        id: row.try_get("id")?, provider: row.try_get("provider")?,
        template: row.try_get("template")?, sender: row.try_get("sender")?,
        recipient: row.try_get("recipient")?, subject: row.try_get("subject")?,
        tenant_id: row.try_get("tenant_id")?, created_at: row.try_get("created_at")?,
    })
}

fn file_from_row(row: crate::database::PgRow) -> Result<AdminFile, sqlx::Error> {
    Ok(AdminFile {
        id: row.try_get("id")?, object_key: row.try_get("object_key")?,
        original_name: row.try_get("original_name")?, content_type: row.try_get("content_type")?,
        size: row.try_get::<i64, _>("size")?.try_into().unwrap_or(0),
        checksum: row.try_get("checksum")?, tenant_id: row.try_get("tenant_id")?,
        created_at: row.try_get("created_at")?,
    })
}