use super::render;
use crate::{Artifact, ArtifactKind, CodegenError};
use appstruct_ir::AppIr;
use quote::quote;
pub(super) fn plan(ir: &AppIr) -> Result<Vec<Artifact>, CodegenError> {
let source = if ir.audit.enabled {
enabled_source(ir)?
} else {
disabled_source()?
};
Ok(vec![Artifact::text(
"backend/src/audit.rs",
source,
ArtifactKind::RustSource,
)])
}
fn enabled_source(ir: &AppIr) -> Result<String, CodegenError> {
let roles = &ir.audit.reader_roles;
let allowed = quote! { false #(|| actor.has_role(#roles))* };
let load = if ir.tenant.enabled {
tenant_load()
} else {
global_load()
};
render(quote! {
use crate::{ApiError, AppState, RequestContext};
use axum::{Json, Router, extract::{Query, State}, http::HeaderMap, routing::get};
use sea_orm::{ConnectionTrait, DbBackend, Statement};
use serde::{Deserialize, Serialize};
pub async fn record<C, T>(
database: &C,
context: &RequestContext<'_>,
entity: &str,
record_id: String,
operation: &str,
before: Option<&T>,
after: Option<&T>,
) -> Result<(), ApiError>
where
C: ConnectionTrait,
T: Serialize,
{
let before = before.map(serde_json::to_value).transpose().map_err(|_| ApiError::Internal)?;
let after = after.map(serde_json::to_value).transpose().map_err(|_| ApiError::Internal)?;
let actor_id = context.actor().map(|actor| actor.id);
database.execute_raw(Statement::from_sql_and_values(
DbBackend::Postgres,
"INSERT INTO \"_appstruct_audit_events\" (id, entity, record_id, operation, actor_id, tenant_id, before, after, occurred_at) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, CURRENT_TIMESTAMP)",
[
uuid::Uuid::now_v7().into(), entity.to_owned().into(), record_id.into(),
operation.to_owned().into(), actor_id.into(), context.tenant().into(),
before.into(), after.into(),
],
)).await?;
Ok(())
}
pub fn router() -> Router<AppState> {
Router::new().route("/api/audit/events", get(list))
}
#[derive(Debug, Default, Deserialize)]
struct ListQuery { page: Option<u64>, page_size: Option<u64> }
#[derive(Debug, Serialize)]
struct AuditEvent {
id: uuid::Uuid,
entity: String,
record_id: String,
operation: String,
actor_id: Option<uuid::Uuid>,
tenant_id: Option<uuid::Uuid>,
before: Option<serde_json::Value>,
after: Option<serde_json::Value>,
occurred_at: chrono::DateTime<chrono::Utc>,
}
#[derive(Debug, Serialize)]
struct ListMeta { page: u64, page_size: u64, total: u64 }
#[derive(Debug, Serialize)]
struct ListResponse { data: Vec<AuditEvent>, meta: ListMeta }
async fn list(
State(state): State<AppState>,
headers: HeaderMap,
Query(query): Query<ListQuery>,
) -> Result<Json<ListResponse>, ApiError> {
let context = state.context(&headers).await?;
let actor = context.actor().ok_or(ApiError::Unauthorized)?;
if !(#allowed) { return Err(ApiError::Forbidden); }
let page = query.page.unwrap_or(1);
let page_size = query.page_size.unwrap_or(50);
if page == 0 || !(1..=100).contains(&page_size) {
return Err(ApiError::InvalidQuery(
"`page` must be at least 1 and `page_size` must be between 1 and 100".to_owned()
));
}
let offset = (page - 1).checked_mul(page_size)
.ok_or_else(|| ApiError::InvalidQuery("pagination is too large".to_owned()))?;
#load
let data = rows.into_iter().map(event_from_row)
.collect::<Result<Vec<_>, sea_orm::DbErr>>()?;
Ok(Json(ListResponse {
data,
meta: ListMeta { page, page_size, total: u64::try_from(total).unwrap_or_default() },
}))
}
fn event_from_row(row: sea_orm::QueryResult) -> Result<AuditEvent, sea_orm::DbErr> {
Ok(AuditEvent {
id: row.try_get("", "id")?, entity: row.try_get("", "entity")?,
record_id: row.try_get("", "record_id")?, operation: row.try_get("", "operation")?,
actor_id: row.try_get("", "actor_id")?, tenant_id: row.try_get("", "tenant_id")?,
before: row.try_get("", "before")?, after: row.try_get("", "after")?,
occurred_at: row.try_get("", "occurred_at")?,
})
}
})
}
fn tenant_load() -> proc_macro2::TokenStream {
quote! {
let tenant = context.require_tenant()?;
let count = state.database.query_one_raw(Statement::from_sql_and_values(
DbBackend::Postgres,
"SELECT COUNT(*) AS total FROM \"_appstruct_audit_events\" WHERE tenant_id = $1",
[tenant.into()],
)).await?.ok_or(ApiError::Internal)?;
let total: i64 = count.try_get("", "total")?;
let rows = state.database.query_all_raw(Statement::from_sql_and_values(
DbBackend::Postgres,
"SELECT id, entity, record_id, operation, actor_id, tenant_id, before, after, occurred_at FROM \"_appstruct_audit_events\" WHERE tenant_id = $1 ORDER BY occurred_at DESC, id DESC LIMIT $2 OFFSET $3",
[tenant.into(), i64::try_from(page_size).unwrap_or(100).into(), i64::try_from(offset).unwrap_or(i64::MAX).into()],
)).await?;
}
}
fn global_load() -> proc_macro2::TokenStream {
quote! {
let count = state.database.query_one_raw(Statement::from_string(
DbBackend::Postgres,
"SELECT COUNT(*) AS total FROM \"_appstruct_audit_events\"".to_owned(),
)).await?.ok_or(ApiError::Internal)?;
let total: i64 = count.try_get("", "total")?;
let rows = state.database.query_all_raw(Statement::from_sql_and_values(
DbBackend::Postgres,
"SELECT id, entity, record_id, operation, actor_id, tenant_id, before, after, occurred_at FROM \"_appstruct_audit_events\" ORDER BY occurred_at DESC, id DESC LIMIT $1 OFFSET $2",
[i64::try_from(page_size).unwrap_or(100).into(), i64::try_from(offset).unwrap_or(i64::MAX).into()],
)).await?;
}
}
fn disabled_source() -> Result<String, CodegenError> {
render(quote! {
use crate::AppState;
use axum::Router;
pub fn router() -> Router<AppState> { Router::new() }
})
}