pdt 0.3.5

Asset store API with relation graphs, tagging, full-text search, multi-instance SQLite tenancy, OIDC auth and Cedar authorization
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96

//! Audit handlers

use axum::{
    extract::{Path, Query},
    Json,
};
use serde::Deserialize;
use utoipa::IntoParams;

use crate::error::Result;
use crate::models::{AuditEntry, PaginatedResponse};
use crate::service::AuditService;

fn default_limit() -> i64 {
    20
}

/// Query parameters for audit list
/// Note: pagination fields inlined to work around serde_urlencoded#33 (flatten breaks numeric deserialize)
#[derive(Debug, Deserialize, IntoParams)]
#[into_params(parameter_in = Query)]
pub struct AuditListParams {
    #[serde(default = "default_limit")]
    pub limit: i64,
    #[serde(default)]
    pub cursor: Option<String>,
    pub entity_type: Option<String>,
    pub entity_id: Option<String>,
    pub user_id: Option<String>,
}

/// Query parameters for asset history
#[derive(Debug, Deserialize, IntoParams)]
#[into_params(parameter_in = Query)]
pub struct HistoryParams {
    #[serde(default = "default_history_limit")]
    pub limit: i64,
}

fn default_history_limit() -> i64 {
    50
}

/// List audit entries
#[utoipa::path(
    get,
    path = "/api/audit",
    params(AuditListParams),
    responses(
        (status = 200, description = "List of audit entries", body = PaginatedResponse<AuditEntry>),
    ),
    tag = "audit",
)]
pub async fn list_audit_entries(
    tx: crate::cedar::enforcement::TenantState,
    Query(params): Query<AuditListParams>,
) -> Result<Json<PaginatedResponse<AuditEntry>>> {
    let (entries, next_cursor) = AuditService::list(
        tx.services(),
        params.entity_type.as_deref(),
        params.entity_id.as_deref(),
        params.user_id.as_deref(),
        params.limit,
        params.cursor.as_deref(),
    )
    .await?;

    Ok(Json(PaginatedResponse {
        data: entries,
        next_cursor,
        total: None,
    }))
}

/// Get history for a specific asset
#[utoipa::path(
    get,
    path = "/api/assets/{id}/history",
    params(
        ("id" = String, Path, description = "Asset ID"),
        HistoryParams,
    ),
    responses(
        (status = 200, description = "Asset change history", body = [AuditEntry]),
        (status = 404, description = "Asset not found"),
    ),
    tag = "audit",
)]
pub async fn get_asset_history(
    tx: crate::cedar::enforcement::TenantState,
    Path(id): Path<String>,
    Query(params): Query<HistoryParams>,
) -> Result<Json<Vec<AuditEntry>>> {
    let entries = AuditService::get_asset_history(tx.services(), &id, params.limit).await?;
    Ok(Json(entries))
}