use async_trait::async_trait;
use chrono::Utc;
use dbnexus::sea_orm::{
ColumnTrait, DbErr, EntityTrait, Order, QueryFilter, QueryOrder, QuerySelect, Set,
};
use dbnexus::DbPool;
use std::sync::Arc;
use crate::domain::auth::{AuditDecision, AuditLogEntry};
use crate::domain::repositories::audit_log_repository::{AuditLogRepository, AuditRepositoryError};
use crate::infrastructure::database::entities::auth::audit_log::{
Column as AuditColumn, Entity as AuditEntity,
};
impl From<DbErr> for AuditRepositoryError {
fn from(err: DbErr) -> Self {
AuditRepositoryError::DatabaseError(anyhow::anyhow!(err))
}
}
impl From<dbnexus::DbError> for AuditRepositoryError {
fn from(err: dbnexus::DbError) -> Self {
use dbnexus::DbError;
match err {
DbError::Connection(db_err) => {
AuditRepositoryError::DatabaseError(anyhow::anyhow!(db_err))
}
DbError::Config(msg) => AuditRepositoryError::DatabaseError(anyhow::anyhow!(
DbErr::Custom(format!("Config: {}", msg))
)),
DbError::Permission(msg) => AuditRepositoryError::DatabaseError(anyhow::anyhow!(
DbErr::Custom(format!("Permission: {}", msg))
)),
DbError::Transaction(msg) => AuditRepositoryError::DatabaseError(anyhow::anyhow!(
DbErr::Custom(format!("Transaction: {}", msg))
)),
DbError::Migration(msg) => AuditRepositoryError::DatabaseError(anyhow::anyhow!(
DbErr::Custom(format!("Migration: {}", msg))
)),
DbError::Cache(msg) | DbError::Query(msg) => {
AuditRepositoryError::DatabaseError(anyhow::anyhow!(DbErr::Custom(msg)))
}
DbError::RateLimited { retry_after_secs } => {
AuditRepositoryError::RateLimited { retry_after_secs }
}
DbError::Unsupported(msg) => AuditRepositoryError::DatabaseError(anyhow::anyhow!(
DbErr::Custom(format!("Unsupported: {}", msg))
)),
DbError::VersionConflict { table, id } => {
AuditRepositoryError::VersionConflict { table, id }
}
}
}
}
#[derive(Clone)]
pub struct AuditLogRepositoryImpl {
pool: Arc<DbPool>,
}
impl AuditLogRepositoryImpl {
pub fn new(pool: Arc<DbPool>) -> Self {
Self { pool }
}
}
#[async_trait]
impl AuditLogRepository for AuditLogRepositoryImpl {
async fn create(&self, entry: &AuditLogEntry) -> Result<AuditLogEntry, AuditRepositoryError> {
let session = self.pool.get_session("admin").await?;
let conn = session.connection()?;
let entry_cloned = entry.clone();
let metadata_value = serde_json::to_value(entry_cloned.metadata).unwrap_or_default();
let scope_used_value = entry_cloned
.scope_used
.map(|s| serde_json::to_value(s).unwrap_or_default());
let ip_address_value = entry_cloned.ip_address.map(|ip| ip.to_string());
let active_model =
crate::infrastructure::database::entities::auth::audit_log::ActiveModel {
id: Set(entry_cloned.id.into()),
api_key_id: Set(entry_cloned.api_key_id.map(Into::into)),
team_id: Set(entry_cloned.team_id.map(Into::into)),
requested_action: Set(entry_cloned.requested_action),
decision: Set(entry_cloned.decision.to_string()),
denial_reason: Set(entry_cloned.denial_reason),
scope_used: Set(scope_used_value),
ip_address: Set(ip_address_value),
trace_id: Set(entry_cloned.trace_id.map(Into::into)),
user_agent: Set(entry_cloned.user_agent),
request_path: Set(entry_cloned.request_path),
request_method: Set(entry_cloned.request_method),
metadata: Set(metadata_value),
..Default::default()
};
AuditEntity::insert(active_model).exec(conn).await?;
Ok(entry.clone())
}
async fn find_by_api_key_id(
&self,
api_key_id: crate::domain::id::Id,
limit: u64,
offset: u64,
) -> Result<Vec<AuditLogEntry>, AuditRepositoryError> {
let session = self.pool.get_session("admin").await?;
let conn = session.connection()?;
let logs = AuditEntity::find()
.filter(AuditColumn::ApiKeyId.eq(api_key_id))
.order_by(AuditColumn::CreatedAt, Order::Desc)
.limit(limit)
.offset(offset)
.all(conn)
.await?;
Ok(logs.into_iter().map(|l| l.into()).collect())
}
async fn find_by_team_id(
&self,
team_id: crate::domain::id::Id,
limit: u64,
offset: u64,
) -> Result<Vec<AuditLogEntry>, AuditRepositoryError> {
let session = self.pool.get_session("admin").await?;
let conn = session.connection()?;
let logs = AuditEntity::find()
.filter(AuditColumn::TeamId.eq(team_id))
.order_by(AuditColumn::CreatedAt, Order::Desc)
.limit(limit)
.offset(offset)
.all(conn)
.await?;
Ok(logs.into_iter().map(|l| l.into()).collect())
}
async fn find_denied_for_key(
&self,
api_key_id: crate::domain::id::Id,
limit: u64,
) -> Result<Vec<AuditLogEntry>, AuditRepositoryError> {
let session = self.pool.get_session("admin").await?;
let conn = session.connection()?;
let logs = AuditEntity::find()
.filter(AuditColumn::ApiKeyId.eq(api_key_id))
.filter(AuditColumn::Decision.eq(AuditDecision::Deny.to_string()))
.order_by(AuditColumn::CreatedAt, Order::Desc)
.limit(limit)
.all(conn)
.await?;
Ok(logs.into_iter().map(|l| l.into()).collect())
}
async fn cleanup_old_logs(&self, retention_days: i64) -> Result<u64, AuditRepositoryError> {
let cutoff = Utc::now() - chrono::Duration::days(retention_days);
let session = self.pool.get_session("admin").await?;
let conn = session.connection()?;
let result = AuditEntity::delete_many()
.filter(AuditColumn::CreatedAt.lt(cutoff))
.exec(conn)
.await?;
Ok(result.rows_affected as u64)
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::common::test_helpers::create_test_db_pool;
use crate::domain::auth::{ApiKeyScope, AuditDecision, AuditLogEntry};
fn sample_scope() -> ApiKeyScope {
ApiKeyScope {
read: true,
write: false,
admin: false,
search_limit: 100,
scrape_limit: 50,
}
}
fn sample_audit_log_entry() -> AuditLogEntry {
AuditLogEntry {
id: crate::domain::id::Id::generate(),
api_key_id: Some(crate::domain::id::Id::generate()),
team_id: Some(crate::domain::id::Id::generate()),
requested_action: "crawl.create".to_string(),
decision: AuditDecision::Allow,
denial_reason: None,
scope_used: Some(sample_scope()),
ip_address: Some(std::net::IpAddr::V4(std::net::Ipv4Addr::new(127, 0, 0, 1))),
trace_id: Some(crate::domain::id::Id::generate()),
user_agent: Some("test-agent/1.0".to_string()),
request_path: Some("/api/v1/crawls".to_string()),
request_method: Some("POST".to_string()),
metadata: serde_json::json!({"request_id": "req-123"}),
created_at: chrono::Utc::now(),
}
}
#[test]
fn test_new_creates_repository_instance() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let pool = create_test_db_pool();
let repo = AuditLogRepositoryImpl::new(pool);
let _clone = repo.clone();
}
#[tokio::test]
async fn test_create_inserts_record() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let repo = AuditLogRepositoryImpl::new(create_test_db_pool());
let entry = sample_audit_log_entry();
let result = repo.create(&entry).await;
assert!(result.is_ok(), "create failed: {:?}", result.err());
let found = repo
.find_by_api_key_id(entry.api_key_id.unwrap(), 10, 0)
.await
.expect("find_by_api_key_id failed");
let matching = found.into_iter().find(|e| e.id == entry.id);
assert!(
matching.is_some(),
"created audit log entry should be findable by api_key_id"
);
}
#[tokio::test]
async fn test_find_by_api_key_id_returns_empty_for_unknown() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let repo = AuditLogRepositoryImpl::new(create_test_db_pool());
let result = repo
.find_by_api_key_id(crate::domain::id::Id::generate(), 10, 0)
.await;
assert!(
result.is_ok(),
"find_by_api_key_id failed: {:?}",
result.err()
);
assert!(
result.unwrap().is_empty(),
"unknown api_key_id should return empty vec"
);
}
#[tokio::test]
async fn test_find_by_team_id_returns_empty_for_unknown() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let repo = AuditLogRepositoryImpl::new(create_test_db_pool());
let result = repo
.find_by_team_id(crate::domain::id::Id::generate(), 10, 0)
.await;
assert!(result.is_ok(), "find_by_team_id failed: {:?}", result.err());
assert!(
result.unwrap().is_empty(),
"unknown team_id should return empty vec"
);
}
#[tokio::test]
async fn test_find_denied_for_key_returns_empty_for_unknown() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let repo = AuditLogRepositoryImpl::new(create_test_db_pool());
let result = repo
.find_denied_for_key(crate::domain::id::Id::generate(), 5)
.await;
assert!(
result.is_ok(),
"find_denied_for_key failed: {:?}",
result.err()
);
assert!(
result.unwrap().is_empty(),
"unknown api_key_id should return empty vec"
);
}
#[tokio::test]
async fn test_cleanup_old_logs_returns_zero_for_no_matching_records() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let repo = AuditLogRepositoryImpl::new(create_test_db_pool());
let result = repo.cleanup_old_logs(30).await;
assert!(
result.is_ok(),
"cleanup_old_logs failed: {:?}",
result.err()
);
let _count = result.unwrap();
}
#[test]
fn test_audit_repository_error_database_error_display() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let err = AuditRepositoryError::DatabaseError(
dbnexus::sea_orm::DbErr::RecordNotFound("audit log missing".to_string()).into(),
);
let msg = format!("{}", err);
assert!(msg.contains("Database error"));
assert!(msg.contains("audit log missing"));
}
#[test]
fn test_audit_repository_error_not_found_display() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let err = AuditRepositoryError::NotFound;
assert_eq!(format!("{}", err), "Audit log not found");
}
#[test]
fn test_audit_repository_error_from_dberr_record_not_found() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let db_err = dbnexus::sea_orm::DbErr::RecordNotFound("not found".to_string());
let repo_err: AuditRepositoryError = db_err.into();
match repo_err {
AuditRepositoryError::DatabaseError(_) => {}
other => panic!("expected DatabaseError variant, got {:?}", other),
}
}
#[test]
fn test_audit_repository_error_from_dberr_query_runtime() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let db_err = dbnexus::sea_orm::DbErr::Query(dbnexus::sea_orm::RuntimeErr::Internal(
"syntax error".to_string(),
));
let repo_err: AuditRepositoryError = db_err.into();
match repo_err {
AuditRepositoryError::DatabaseError(_) => {}
other => panic!("expected DatabaseError variant, got {:?}", other),
}
}
#[test]
fn test_audit_repository_error_from_dberr_connection_acquire() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let db_err =
dbnexus::sea_orm::DbErr::ConnectionAcquire(dbnexus::sea_orm::ConnAcquireErr::Timeout);
let repo_err: AuditRepositoryError = db_err.into();
match repo_err {
AuditRepositoryError::DatabaseError(_) => {}
other => panic!("expected DatabaseError variant, got {:?}", other),
}
}
#[test]
fn test_audit_repository_error_from_dberr_record_not_inserted() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let db_err = dbnexus::sea_orm::DbErr::RecordNotInserted;
let repo_err: AuditRepositoryError = db_err.into();
match repo_err {
AuditRepositoryError::DatabaseError(_) => {}
other => panic!("expected DatabaseError variant, got {:?}", other),
}
}
#[test]
fn test_audit_repository_error_from_dbnexus_db_error_connection() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let inner =
dbnexus::sea_orm::DbErr::ConnectionAcquire(dbnexus::sea_orm::ConnAcquireErr::Timeout);
let db_err = dbnexus::DbError::Connection(inner);
let repo_err: AuditRepositoryError = db_err.into();
match repo_err {
AuditRepositoryError::DatabaseError(ref err) => {
let db_err = err
.downcast_ref::<dbnexus::sea_orm::DbErr>()
.expect("expected DbErr wrapped by anyhow");
match db_err {
dbnexus::sea_orm::DbErr::ConnectionAcquire(_) => {}
other => panic!("expected ConnectionAcquire, got {:?}", other),
}
}
other => panic!("expected DatabaseError(ConnectionAcquire), got {:?}", other),
}
}
#[test]
fn test_audit_repository_error_from_dbnexus_db_error_config() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let db_err = dbnexus::DbError::Config("invalid url".to_string());
let repo_err: AuditRepositoryError = db_err.into();
match repo_err {
AuditRepositoryError::DatabaseError(ref err) => {
let db_err = err
.downcast_ref::<dbnexus::sea_orm::DbErr>()
.expect("expected DbErr wrapped by anyhow");
match db_err {
dbnexus::sea_orm::DbErr::Custom(msg) => {
assert!(msg.contains("Config"));
assert!(msg.contains("invalid url"));
}
other => panic!("expected Custom, got {:?}", other),
}
}
other => panic!("expected DatabaseError(Custom), got {:?}", other),
}
}
#[test]
fn test_audit_repository_error_from_dbnexus_db_error_permission() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let db_err = dbnexus::DbError::Permission("forbidden".to_string());
let repo_err: AuditRepositoryError = db_err.into();
match repo_err {
AuditRepositoryError::DatabaseError(ref err) => {
let db_err = err
.downcast_ref::<dbnexus::sea_orm::DbErr>()
.expect("expected DbErr wrapped by anyhow");
match db_err {
dbnexus::sea_orm::DbErr::Custom(msg) => {
assert!(msg.contains("Permission"));
assert!(msg.contains("forbidden"));
}
other => panic!("expected Custom, got {:?}", other),
}
}
other => panic!("expected DatabaseError(Custom), got {:?}", other),
}
}
#[test]
fn test_audit_repository_error_from_dbnexus_db_error_transaction() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let db_err = dbnexus::DbError::Transaction("deadlock".to_string());
let repo_err: AuditRepositoryError = db_err.into();
match repo_err {
AuditRepositoryError::DatabaseError(ref err) => {
let db_err = err
.downcast_ref::<dbnexus::sea_orm::DbErr>()
.expect("expected DbErr wrapped by anyhow");
match db_err {
dbnexus::sea_orm::DbErr::Custom(msg) => {
assert!(msg.contains("Transaction"));
assert!(msg.contains("deadlock"));
}
other => panic!("expected Custom, got {:?}", other),
}
}
other => panic!("expected DatabaseError(Custom), got {:?}", other),
}
}
#[test]
fn test_audit_repository_error_from_dbnexus_db_error_migration() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let db_err = dbnexus::DbError::Migration("schema mismatch".to_string());
let repo_err: AuditRepositoryError = db_err.into();
match repo_err {
AuditRepositoryError::DatabaseError(ref err) => {
let db_err = err
.downcast_ref::<dbnexus::sea_orm::DbErr>()
.expect("expected DbErr wrapped by anyhow");
match db_err {
dbnexus::sea_orm::DbErr::Custom(msg) => {
assert!(msg.contains("Migration"));
assert!(msg.contains("schema mismatch"));
}
other => panic!("expected Custom, got {:?}", other),
}
}
other => panic!("expected DatabaseError(Custom), got {:?}", other),
}
}
#[test]
fn test_audit_repository_error_from_dbnexus_rate_limited_preserves_retry_after() {
let db_err = dbnexus::DbError::RateLimited {
retry_after_secs: Some(7),
};
let repo_err: AuditRepositoryError = db_err.into();
match repo_err {
AuditRepositoryError::RateLimited { retry_after_secs } => {
assert_eq!(retry_after_secs, Some(7));
}
other => panic!("expected RateLimited, got {:?}", other),
}
assert_eq!(
format!(
"{}",
AuditRepositoryError::RateLimited {
retry_after_secs: None
}
),
"Database error: Rate limited (retry_after=None)"
);
}
#[test]
fn test_audit_repository_error_from_dbnexus_version_conflict_preserves_fields() {
let db_err = dbnexus::DbError::VersionConflict {
table: "crawl_tasks".to_string(),
id: 42,
};
let repo_err: AuditRepositoryError = db_err.into();
match repo_err {
AuditRepositoryError::VersionConflict { table, id } => {
assert_eq!(table, "crawl_tasks");
assert_eq!(id, 42);
}
other => panic!("expected VersionConflict, got {:?}", other),
}
assert_eq!(
format!(
"{}",
AuditRepositoryError::VersionConflict {
table: "crawl_tasks".to_string(),
id: 42
}
),
"Database error: Version conflict on table 'crawl_tasks' for id 42"
);
}
#[test]
fn test_audit_decision_allow_display() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
assert_eq!(format!("{}", AuditDecision::Allow), "ALLOW");
}
#[test]
fn test_audit_decision_deny_display() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
assert_eq!(format!("{}", AuditDecision::Deny), "DENY");
}
#[test]
fn test_audit_log_entry_construction_does_not_panic() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let entry = sample_audit_log_entry();
assert_eq!(entry.decision, AuditDecision::Allow);
assert_eq!(entry.requested_action, "crawl.create");
assert!(entry.scope_used.is_some());
assert!(entry.ip_address.is_some());
}
#[test]
fn test_audit_log_entry_with_deny_decision() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let mut entry = sample_audit_log_entry();
entry.decision = AuditDecision::Deny;
entry.denial_reason = Some("insufficient scope".to_string());
assert_eq!(entry.decision.to_string(), "DENY");
assert!(entry.denial_reason.is_some());
}
}