614 lines
19 KiB
Rust
614 lines
19 KiB
Rust
use axum::{
|
|
extract::{Path, Query, State},
|
|
http::{HeaderMap, StatusCode},
|
|
response::IntoResponse,
|
|
routing::{get, put, delete},
|
|
Json, Router,
|
|
};
|
|
use serde::{Deserialize, Serialize};
|
|
use std::sync::Arc;
|
|
use uuid::Uuid;
|
|
|
|
use dd0c_route::auth::{AuthContext, AuthError, AuthProvider, Role};
|
|
use dd0c_route::config::AppConfig;
|
|
|
|
pub struct ApiState {
|
|
pub auth: Arc<dyn AuthProvider>,
|
|
pub pg_pool: sqlx::PgPool,
|
|
pub ts_pool: sqlx::PgPool,
|
|
pub _config: Arc<AppConfig>,
|
|
}
|
|
|
|
pub fn create_api_router(state: Arc<ApiState>) -> Router {
|
|
Router::new()
|
|
// Dashboard analytics
|
|
.route("/api/v1/analytics/summary", get(get_analytics_summary))
|
|
.route("/api/v1/analytics/timeseries", get(get_analytics_timeseries))
|
|
.route("/api/v1/analytics/models", get(get_model_breakdown))
|
|
// Routing rules
|
|
.route("/api/v1/rules", get(list_rules).post(create_rule))
|
|
.route("/api/v1/rules/:id", put(update_rule).delete(delete_rule))
|
|
// API keys
|
|
.route("/api/v1/keys", get(list_keys).post(create_key))
|
|
.route("/api/v1/keys/:id", delete(revoke_key))
|
|
// Provider configs
|
|
.route("/api/v1/providers", get(list_providers).post(upsert_provider))
|
|
// Org settings
|
|
.route("/api/v1/org", get(get_org))
|
|
// Health
|
|
.route("/health", get(health))
|
|
.with_state(state)
|
|
}
|
|
|
|
async fn health() -> &'static str { "ok" }
|
|
|
|
// --- Analytics Endpoints ---
|
|
|
|
#[derive(Deserialize)]
|
|
pub struct TimeRange {
|
|
pub from: Option<String>,
|
|
pub _to: Option<String>,
|
|
pub interval: Option<String>, // "hour" or "day"
|
|
}
|
|
|
|
#[derive(Serialize)]
|
|
pub struct AnalyticsSummary {
|
|
pub total_requests: i64,
|
|
pub total_cost_original: f64,
|
|
pub total_cost_actual: f64,
|
|
pub total_cost_saved: f64,
|
|
pub savings_pct: f64,
|
|
pub avg_latency_ms: i32,
|
|
pub p99_latency_ms: i32,
|
|
pub routing_decisions: RoutingBreakdown,
|
|
}
|
|
|
|
#[derive(Serialize)]
|
|
pub struct RoutingBreakdown {
|
|
pub passthrough: i64,
|
|
pub cheapest: i64,
|
|
pub cascading: i64,
|
|
}
|
|
|
|
async fn get_analytics_summary(
|
|
State(state): State<Arc<ApiState>>,
|
|
headers: HeaderMap,
|
|
Query(range): Query<TimeRange>,
|
|
) -> Result<Json<AnalyticsSummary>, ApiError> {
|
|
let auth = state.auth.authenticate(&headers).await?;
|
|
let _from = range.from.unwrap_or_else(|| "now() - interval '7 days'".to_string());
|
|
|
|
let row = sqlx::query_as::<_, (i64, f64, f64, f64, i32, i32, i64, i64, i64)>(
|
|
"SELECT
|
|
COUNT(*),
|
|
COALESCE(SUM(cost_original), 0)::float8,
|
|
COALESCE(SUM(cost_actual), 0)::float8,
|
|
COALESCE(SUM(cost_saved), 0)::float8,
|
|
COALESCE(AVG(latency_ms), 0)::int,
|
|
COALESCE(PERCENTILE_CONT(0.99) WITHIN GROUP (ORDER BY latency_ms), 0)::int,
|
|
COUNT(*) FILTER (WHERE strategy = 'passthrough'),
|
|
COUNT(*) FILTER (WHERE strategy = 'cheapest'),
|
|
COUNT(*) FILTER (WHERE strategy = 'cascading')
|
|
FROM request_events
|
|
WHERE org_id = $1 AND time >= now() - interval '7 days'"
|
|
)
|
|
.bind(auth.org_id.parse::<Uuid>().unwrap_or_default())
|
|
.fetch_one(&state.ts_pool)
|
|
.await
|
|
.map_err(|e| ApiError::Internal(e.to_string()))?;
|
|
|
|
let savings_pct = if row.1 > 0.0 { (row.3 / row.1) * 100.0 } else { 0.0 };
|
|
|
|
Ok(Json(AnalyticsSummary {
|
|
total_requests: row.0,
|
|
total_cost_original: row.1,
|
|
total_cost_actual: row.2,
|
|
total_cost_saved: row.3,
|
|
savings_pct,
|
|
avg_latency_ms: row.4,
|
|
p99_latency_ms: row.5,
|
|
routing_decisions: RoutingBreakdown {
|
|
passthrough: row.6,
|
|
cheapest: row.7,
|
|
cascading: row.8,
|
|
},
|
|
}))
|
|
}
|
|
|
|
#[derive(Serialize)]
|
|
pub struct TimeseriesPoint {
|
|
pub bucket: String,
|
|
pub request_count: i64,
|
|
pub cost_saved: f64,
|
|
pub avg_latency_ms: i32,
|
|
}
|
|
|
|
async fn get_analytics_timeseries(
|
|
State(state): State<Arc<ApiState>>,
|
|
headers: HeaderMap,
|
|
Query(range): Query<TimeRange>,
|
|
) -> Result<Json<Vec<TimeseriesPoint>>, ApiError> {
|
|
let auth = state.auth.authenticate(&headers).await?;
|
|
let interval = range.interval.unwrap_or_else(|| "hour".to_string());
|
|
|
|
let view = if interval == "day" { "request_events_daily" } else { "request_events_hourly" };
|
|
|
|
let rows = sqlx::query_as::<_, (chrono::DateTime<chrono::Utc>, i64, f64, i32)>(
|
|
&format!(
|
|
"SELECT bucket, request_count, COALESCE(total_cost_saved, 0)::float8, COALESCE(avg_latency_ms, 0)::int
|
|
FROM {}
|
|
WHERE org_id = $1 AND bucket >= now() - interval '7 days'
|
|
ORDER BY bucket",
|
|
view
|
|
)
|
|
)
|
|
.bind(auth.org_id.parse::<Uuid>().unwrap_or_default())
|
|
.fetch_all(&state.ts_pool)
|
|
.await
|
|
.map_err(|e| ApiError::Internal(e.to_string()))?;
|
|
|
|
Ok(Json(rows.iter().map(|r| TimeseriesPoint {
|
|
bucket: r.0.to_rfc3339(),
|
|
request_count: r.1,
|
|
cost_saved: r.2,
|
|
avg_latency_ms: r.3,
|
|
}).collect()))
|
|
}
|
|
|
|
#[derive(Serialize)]
|
|
pub struct ModelBreakdown {
|
|
pub model: String,
|
|
pub request_count: i64,
|
|
pub total_tokens: i64,
|
|
pub total_cost: f64,
|
|
}
|
|
|
|
async fn get_model_breakdown(
|
|
State(state): State<Arc<ApiState>>,
|
|
headers: HeaderMap,
|
|
) -> Result<Json<Vec<ModelBreakdown>>, ApiError> {
|
|
let auth = state.auth.authenticate(&headers).await?;
|
|
|
|
let rows = sqlx::query_as::<_, (String, i64, i64, f64)>(
|
|
"SELECT original_model, COUNT(*), SUM(prompt_tokens + completion_tokens), COALESCE(SUM(cost_actual), 0)::float8
|
|
FROM request_events
|
|
WHERE org_id = $1 AND time >= now() - interval '7 days'
|
|
GROUP BY original_model
|
|
ORDER BY COUNT(*) DESC"
|
|
)
|
|
.bind(auth.org_id.parse::<Uuid>().unwrap_or_default())
|
|
.fetch_all(&state.ts_pool)
|
|
.await
|
|
.map_err(|e| ApiError::Internal(e.to_string()))?;
|
|
|
|
Ok(Json(rows.iter().map(|r| ModelBreakdown {
|
|
model: r.0.clone(),
|
|
request_count: r.1,
|
|
total_tokens: r.2,
|
|
total_cost: r.3,
|
|
}).collect()))
|
|
}
|
|
|
|
// --- Routing Rules CRUD ---
|
|
|
|
#[derive(Serialize, Deserialize)]
|
|
pub struct RoutingRuleDto {
|
|
pub id: Option<Uuid>,
|
|
pub priority: i32,
|
|
pub name: String,
|
|
pub match_model: Option<String>,
|
|
pub match_feature: Option<String>,
|
|
pub match_team: Option<String>,
|
|
pub match_complexity: Option<String>,
|
|
pub strategy: String,
|
|
pub target_model: Option<String>,
|
|
pub target_provider: Option<String>,
|
|
pub fallback_models: Option<Vec<String>>,
|
|
pub enabled: bool,
|
|
}
|
|
|
|
async fn list_rules(
|
|
State(state): State<Arc<ApiState>>,
|
|
headers: HeaderMap,
|
|
) -> Result<Json<Vec<RoutingRuleDto>>, ApiError> {
|
|
let auth = state.auth.authenticate(&headers).await?;
|
|
|
|
let rows = sqlx::query_as::<_, (Uuid, i32, String, Option<String>, Option<String>, Option<String>, Option<String>, String, Option<String>, Option<String>, Option<Vec<String>>, bool)>(
|
|
"SELECT id, priority, name, match_model, match_feature, match_team, match_complexity, strategy, target_model, target_provider, fallback_models, enabled
|
|
FROM routing_rules WHERE org_id = $1 ORDER BY priority"
|
|
)
|
|
.bind(auth.org_id.parse::<Uuid>().unwrap_or_default())
|
|
.fetch_all(&state.pg_pool)
|
|
.await
|
|
.map_err(|e| ApiError::Internal(e.to_string()))?;
|
|
|
|
Ok(Json(rows.iter().map(|r| RoutingRuleDto {
|
|
id: Some(r.0),
|
|
priority: r.1,
|
|
name: r.2.clone(),
|
|
match_model: r.3.clone(),
|
|
match_feature: r.4.clone(),
|
|
match_team: r.5.clone(),
|
|
match_complexity: r.6.clone(),
|
|
strategy: r.7.clone(),
|
|
target_model: r.8.clone(),
|
|
target_provider: r.9.clone(),
|
|
fallback_models: r.10.clone(),
|
|
enabled: r.11,
|
|
}).collect()))
|
|
}
|
|
|
|
async fn create_rule(
|
|
State(state): State<Arc<ApiState>>,
|
|
headers: HeaderMap,
|
|
Json(rule): Json<RoutingRuleDto>,
|
|
) -> Result<(StatusCode, Json<RoutingRuleDto>), ApiError> {
|
|
let auth = state.auth.authenticate(&headers).await?;
|
|
require_role(&auth, Role::Owner)?;
|
|
|
|
let id = Uuid::new_v4();
|
|
sqlx::query(
|
|
"INSERT INTO routing_rules (id, org_id, priority, name, match_model, match_feature, match_team, match_complexity, strategy, target_model, target_provider, fallback_models, enabled)
|
|
VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13)"
|
|
)
|
|
.bind(id)
|
|
.bind(auth.org_id.parse::<Uuid>().unwrap_or_default())
|
|
.bind(rule.priority)
|
|
.bind(&rule.name)
|
|
.bind(&rule.match_model)
|
|
.bind(&rule.match_feature)
|
|
.bind(&rule.match_team)
|
|
.bind(&rule.match_complexity)
|
|
.bind(&rule.strategy)
|
|
.bind(&rule.target_model)
|
|
.bind(&rule.target_provider)
|
|
.bind(&rule.fallback_models)
|
|
.bind(rule.enabled)
|
|
.execute(&state.pg_pool)
|
|
.await
|
|
.map_err(|e| ApiError::Internal(e.to_string()))?;
|
|
|
|
let mut created = rule;
|
|
created.id = Some(id);
|
|
Ok((StatusCode::CREATED, Json(created)))
|
|
}
|
|
|
|
async fn update_rule(
|
|
State(state): State<Arc<ApiState>>,
|
|
headers: HeaderMap,
|
|
Path(id): Path<Uuid>,
|
|
Json(rule): Json<RoutingRuleDto>,
|
|
) -> Result<StatusCode, ApiError> {
|
|
let auth = state.auth.authenticate(&headers).await?;
|
|
require_role(&auth, Role::Owner)?;
|
|
|
|
let result = sqlx::query(
|
|
"UPDATE routing_rules SET priority=$1, name=$2, match_model=$3, match_feature=$4, match_team=$5, match_complexity=$6, strategy=$7, target_model=$8, target_provider=$9, fallback_models=$10, enabled=$11
|
|
WHERE id=$12 AND org_id=$13"
|
|
)
|
|
.bind(rule.priority)
|
|
.bind(&rule.name)
|
|
.bind(&rule.match_model)
|
|
.bind(&rule.match_feature)
|
|
.bind(&rule.match_team)
|
|
.bind(&rule.match_complexity)
|
|
.bind(&rule.strategy)
|
|
.bind(&rule.target_model)
|
|
.bind(&rule.target_provider)
|
|
.bind(&rule.fallback_models)
|
|
.bind(rule.enabled)
|
|
.bind(id)
|
|
.bind(auth.org_id.parse::<Uuid>().unwrap_or_default())
|
|
.execute(&state.pg_pool)
|
|
.await
|
|
.map_err(|e| ApiError::Internal(e.to_string()))?;
|
|
|
|
if result.rows_affected() == 0 {
|
|
return Err(ApiError::NotFound);
|
|
}
|
|
Ok(StatusCode::NO_CONTENT)
|
|
}
|
|
|
|
async fn delete_rule(
|
|
State(state): State<Arc<ApiState>>,
|
|
headers: HeaderMap,
|
|
Path(id): Path<Uuid>,
|
|
) -> Result<StatusCode, ApiError> {
|
|
let auth = state.auth.authenticate(&headers).await?;
|
|
require_role(&auth, Role::Owner)?;
|
|
|
|
let result = sqlx::query("DELETE FROM routing_rules WHERE id=$1 AND org_id=$2")
|
|
.bind(id)
|
|
.bind(auth.org_id.parse::<Uuid>().unwrap_or_default())
|
|
.execute(&state.pg_pool)
|
|
.await
|
|
.map_err(|e| ApiError::Internal(e.to_string()))?;
|
|
|
|
if result.rows_affected() == 0 {
|
|
return Err(ApiError::NotFound);
|
|
}
|
|
Ok(StatusCode::NO_CONTENT)
|
|
}
|
|
|
|
// --- API Keys ---
|
|
|
|
#[derive(Serialize)]
|
|
pub struct ApiKeyDto {
|
|
pub id: Uuid,
|
|
pub name: String,
|
|
pub key_prefix: String,
|
|
pub scopes: Vec<String>,
|
|
pub last_used_at: Option<chrono::DateTime<chrono::Utc>>,
|
|
pub created_at: chrono::DateTime<chrono::Utc>,
|
|
}
|
|
|
|
#[derive(Serialize)]
|
|
pub struct ApiKeyCreated {
|
|
pub id: Uuid,
|
|
pub key: String, // Only returned on creation
|
|
pub name: String,
|
|
}
|
|
|
|
#[derive(Deserialize)]
|
|
pub struct CreateKeyRequest {
|
|
pub name: String,
|
|
pub scopes: Option<Vec<String>>,
|
|
}
|
|
|
|
async fn list_keys(
|
|
State(state): State<Arc<ApiState>>,
|
|
headers: HeaderMap,
|
|
) -> Result<Json<Vec<ApiKeyDto>>, ApiError> {
|
|
let auth = state.auth.authenticate(&headers).await?;
|
|
|
|
let rows = sqlx::query_as::<_, (Uuid, String, String, Vec<String>, Option<chrono::DateTime<chrono::Utc>>, chrono::DateTime<chrono::Utc>)>(
|
|
"SELECT id, name, key_prefix, scopes, last_used_at, created_at
|
|
FROM api_keys WHERE org_id = $1 AND revoked_at IS NULL ORDER BY created_at DESC"
|
|
)
|
|
.bind(auth.org_id.parse::<Uuid>().unwrap_or_default())
|
|
.fetch_all(&state.pg_pool)
|
|
.await
|
|
.map_err(|e| ApiError::Internal(e.to_string()))?;
|
|
|
|
Ok(Json(rows.iter().map(|r| ApiKeyDto {
|
|
id: r.0,
|
|
name: r.1.clone(),
|
|
key_prefix: r.2.clone(),
|
|
scopes: r.3.clone(),
|
|
last_used_at: r.4,
|
|
created_at: r.5,
|
|
}).collect()))
|
|
}
|
|
|
|
async fn create_key(
|
|
State(state): State<Arc<ApiState>>,
|
|
headers: HeaderMap,
|
|
Json(req): Json<CreateKeyRequest>,
|
|
) -> Result<(StatusCode, Json<ApiKeyCreated>), ApiError> {
|
|
let auth = state.auth.authenticate(&headers).await?;
|
|
require_role(&auth, Role::Owner)?;
|
|
|
|
// Generate key: dd0c_ + 32 random chars
|
|
let raw_key = format!("dd0c_{}", generate_random_key(32));
|
|
let prefix = &raw_key[..8];
|
|
let hash = bcrypt::hash(&raw_key, 10).map_err(|e| ApiError::Internal(e.to_string()))?;
|
|
|
|
let id = Uuid::new_v4();
|
|
let scopes = req.scopes.unwrap_or_else(|| vec!["proxy".to_string()]);
|
|
|
|
sqlx::query(
|
|
"INSERT INTO api_keys (id, org_id, key_prefix, key_hash, name, scopes) VALUES ($1, $2, $3, $4, $5, $6)"
|
|
)
|
|
.bind(id)
|
|
.bind(auth.org_id.parse::<Uuid>().unwrap_or_default())
|
|
.bind(prefix)
|
|
.bind(&hash)
|
|
.bind(&req.name)
|
|
.bind(&scopes)
|
|
.execute(&state.pg_pool)
|
|
.await
|
|
.map_err(|e| ApiError::Internal(e.to_string()))?;
|
|
|
|
Ok((StatusCode::CREATED, Json(ApiKeyCreated {
|
|
id,
|
|
key: raw_key,
|
|
name: req.name,
|
|
})))
|
|
}
|
|
|
|
async fn revoke_key(
|
|
State(state): State<Arc<ApiState>>,
|
|
headers: HeaderMap,
|
|
Path(id): Path<Uuid>,
|
|
) -> Result<StatusCode, ApiError> {
|
|
let auth = state.auth.authenticate(&headers).await?;
|
|
require_role(&auth, Role::Owner)?;
|
|
|
|
let result = sqlx::query(
|
|
"UPDATE api_keys SET revoked_at = now() WHERE id = $1 AND org_id = $2 AND revoked_at IS NULL"
|
|
)
|
|
.bind(id)
|
|
.bind(auth.org_id.parse::<Uuid>().unwrap_or_default())
|
|
.execute(&state.pg_pool)
|
|
.await
|
|
.map_err(|e| ApiError::Internal(e.to_string()))?;
|
|
|
|
if result.rows_affected() == 0 {
|
|
return Err(ApiError::NotFound);
|
|
}
|
|
Ok(StatusCode::NO_CONTENT)
|
|
}
|
|
|
|
// --- Providers ---
|
|
|
|
#[derive(Serialize, Deserialize)]
|
|
pub struct ProviderDto {
|
|
pub provider: String,
|
|
pub base_url: Option<String>,
|
|
pub is_default: bool,
|
|
pub has_key: bool,
|
|
}
|
|
|
|
async fn list_providers(
|
|
State(state): State<Arc<ApiState>>,
|
|
headers: HeaderMap,
|
|
) -> Result<Json<Vec<ProviderDto>>, ApiError> {
|
|
let auth = state.auth.authenticate(&headers).await?;
|
|
|
|
let rows = sqlx::query_as::<_, (String, Option<String>, bool)>(
|
|
"SELECT provider, base_url, is_default FROM provider_configs WHERE org_id = $1"
|
|
)
|
|
.bind(auth.org_id.parse::<Uuid>().unwrap_or_default())
|
|
.fetch_all(&state.pg_pool)
|
|
.await
|
|
.map_err(|e| ApiError::Internal(e.to_string()))?;
|
|
|
|
Ok(Json(rows.iter().map(|r| ProviderDto {
|
|
provider: r.0.clone(),
|
|
base_url: r.1.clone(),
|
|
is_default: r.2,
|
|
has_key: true,
|
|
}).collect()))
|
|
}
|
|
|
|
#[derive(Deserialize)]
|
|
pub struct UpsertProviderRequest {
|
|
pub provider: String,
|
|
pub api_key: String,
|
|
pub base_url: Option<String>,
|
|
pub is_default: bool,
|
|
}
|
|
|
|
async fn upsert_provider(
|
|
State(state): State<Arc<ApiState>>,
|
|
headers: HeaderMap,
|
|
Json(req): Json<UpsertProviderRequest>,
|
|
) -> Result<StatusCode, ApiError> {
|
|
let auth = state.auth.authenticate(&headers).await?;
|
|
require_role(&auth, Role::Owner)?;
|
|
|
|
// Encrypt API key with AES-256-GCM before storing
|
|
let encryption_key = std::env::var("PROVIDER_KEY_ENCRYPTION_KEY")
|
|
.unwrap_or_else(|_| "0".repeat(64)); // 32-byte hex key
|
|
let key_bytes = hex::decode(&encryption_key)
|
|
.unwrap_or_else(|_| vec![0u8; 32]);
|
|
|
|
use aes_gcm::{Aes256Gcm, KeyInit, aead::Aead};
|
|
use aes_gcm::Nonce;
|
|
|
|
let cipher = Aes256Gcm::new_from_slice(&key_bytes)
|
|
.map_err(|e| ApiError::Internal(format!("Encryption key error: {}", e)))?;
|
|
let mut nonce_bytes = [0u8; 12];
|
|
getrandom::getrandom(&mut nonce_bytes)
|
|
.map_err(|e| ApiError::Internal(format!("RNG error: {}", e)))?;
|
|
let nonce = Nonce::from_slice(&nonce_bytes);
|
|
let ciphertext = cipher.encrypt(nonce, req.api_key.as_bytes())
|
|
.map_err(|e| ApiError::Internal(format!("Encryption error: {}", e)))?;
|
|
|
|
// Store as nonce || ciphertext
|
|
let mut encrypted = Vec::with_capacity(12 + ciphertext.len());
|
|
encrypted.extend_from_slice(&nonce_bytes);
|
|
encrypted.extend_from_slice(&ciphertext);
|
|
|
|
sqlx::query(
|
|
"INSERT INTO provider_configs (id, org_id, provider, encrypted_api_key, base_url, is_default)
|
|
VALUES (gen_random_uuid(), $1, $2, $3, $4, $5)
|
|
ON CONFLICT (org_id, provider) DO UPDATE SET encrypted_api_key = $3, base_url = $4, is_default = $5"
|
|
)
|
|
.bind(auth.org_id.parse::<Uuid>().unwrap_or_default())
|
|
.bind(&req.provider)
|
|
.bind(&encrypted)
|
|
.bind(&req.base_url)
|
|
.bind(req.is_default)
|
|
.execute(&state.pg_pool)
|
|
.await
|
|
.map_err(|e| ApiError::Internal(e.to_string()))?;
|
|
|
|
Ok(StatusCode::OK)
|
|
}
|
|
|
|
// --- Org ---
|
|
|
|
#[derive(Serialize)]
|
|
pub struct OrgDto {
|
|
pub id: Uuid,
|
|
pub name: String,
|
|
pub slug: String,
|
|
pub tier: String,
|
|
}
|
|
|
|
async fn get_org(
|
|
State(state): State<Arc<ApiState>>,
|
|
headers: HeaderMap,
|
|
) -> Result<Json<OrgDto>, ApiError> {
|
|
let auth = state.auth.authenticate(&headers).await?;
|
|
|
|
let row = sqlx::query_as::<_, (Uuid, String, String, String)>(
|
|
"SELECT id, name, slug, tier FROM organizations WHERE id = $1"
|
|
)
|
|
.bind(auth.org_id.parse::<Uuid>().unwrap_or_default())
|
|
.fetch_optional(&state.pg_pool)
|
|
.await
|
|
.map_err(|e| ApiError::Internal(e.to_string()))?
|
|
.ok_or(ApiError::NotFound)?;
|
|
|
|
Ok(Json(OrgDto {
|
|
id: row.0,
|
|
name: row.1,
|
|
slug: row.2,
|
|
tier: row.3,
|
|
}))
|
|
}
|
|
|
|
// --- Helpers ---
|
|
|
|
fn require_role(auth: &AuthContext, required: Role) -> Result<(), ApiError> {
|
|
if auth.role != required && auth.role != Role::Owner {
|
|
return Err(ApiError::Forbidden);
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
fn generate_random_key(len: usize) -> String {
|
|
use std::fmt::Write;
|
|
let mut key = String::with_capacity(len);
|
|
for _ in 0..len {
|
|
let byte: u8 = rand_byte();
|
|
let _ = write!(key, "{:x}", byte % 16);
|
|
}
|
|
key
|
|
}
|
|
|
|
fn rand_byte() -> u8 {
|
|
// Simple random byte using getrandom
|
|
let mut buf = [0u8; 1];
|
|
getrandom::getrandom(&mut buf).unwrap_or_default();
|
|
buf[0]
|
|
}
|
|
|
|
// --- Error types ---
|
|
|
|
#[derive(Debug, thiserror::Error)]
|
|
pub enum ApiError {
|
|
#[error("Authentication failed")]
|
|
AuthError(#[from] AuthError),
|
|
#[error("Forbidden")]
|
|
Forbidden,
|
|
#[error("Not found")]
|
|
NotFound,
|
|
#[error("Internal error: {0}")]
|
|
Internal(String),
|
|
}
|
|
|
|
impl IntoResponse for ApiError {
|
|
fn into_response(self) -> axum::response::Response {
|
|
let (status, msg) = match &self {
|
|
ApiError::AuthError(_) => (StatusCode::UNAUTHORIZED, self.to_string()),
|
|
ApiError::Forbidden => (StatusCode::FORBIDDEN, self.to_string()),
|
|
ApiError::NotFound => (StatusCode::NOT_FOUND, self.to_string()),
|
|
ApiError::Internal(_) => (StatusCode::INTERNAL_SERVER_ERROR, "Internal error".to_string()),
|
|
};
|
|
(status, serde_json::json!({"error": msg}).to_string()).into_response()
|
|
}
|
|
}
|