use crate::common::error::CrawlRsError;
use crate::domain::auth::{ApiKeyScope, AuditDecision, AuditLogEntry};
use crate::domain::repositories::audit_log_repository::{AuditLogRepository, AuditRepositoryError};
use log::debug;
use std::sync::Arc;
use thiserror::Error;
pub use crate::domain::services::audit_log_builder::AuditLogBuilder;
#[derive(Debug, Error)]
pub enum AuditServiceError {
#[error("Repository error: {0}")]
RepositoryError(#[from] AuditRepositoryError),
}
impl From<AuditServiceError> for CrawlRsError {
fn from(error: AuditServiceError) -> Self {
match error {
AuditServiceError::RepositoryError(repo_err) => match repo_err {
AuditRepositoryError::DatabaseError(anyhow_err) => {
#[cfg(any(feature = "platform", feature = "web-axum"))]
if let Some(db_err) = anyhow_err
.downcast_ref::<dbnexus::sea_orm::DbErr>()
.cloned()
{
return CrawlRsError::Database(db_err);
}
#[cfg(not(any(feature = "platform", feature = "web-axum")))]
return CrawlRsError::Database(anyhow_err.to_string());
#[cfg(any(feature = "platform", feature = "web-axum"))]
return CrawlRsError::Other(format!("Database error: {}", anyhow_err));
}
AuditRepositoryError::RateLimited { retry_after_secs } => {
let message = format!("Rate limited (retry_after={retry_after_secs:?})");
#[cfg(any(feature = "platform", feature = "web-axum"))]
return CrawlRsError::Database(dbnexus::sea_orm::DbErr::Custom(message));
#[cfg(not(any(feature = "platform", feature = "web-axum")))]
return CrawlRsError::Database(message);
}
AuditRepositoryError::VersionConflict { table, id } => {
let message = format!("Version conflict on table '{table}' for id {id}");
#[cfg(any(feature = "platform", feature = "web-axum"))]
return CrawlRsError::Database(dbnexus::sea_orm::DbErr::Custom(message));
#[cfg(not(any(feature = "platform", feature = "web-axum")))]
return CrawlRsError::Database(message);
}
AuditRepositoryError::NotFound => CrawlRsError::Other(repo_err.to_string()),
},
}
}
}
#[cfg(test)]
mod tests {
use super::*;
use std::net::Ipv4Addr;
use crate::domain::repositories::audit_log_repository::AuditLogRepository;
use async_trait::async_trait;
use std::sync::Mutex;
struct MockAuditLogRepository {
created: Mutex<Vec<AuditLogEntry>>,
find_results: Mutex<Vec<AuditLogEntry>>,
cleanup_count: u64,
fail_all: bool,
}
impl MockAuditLogRepository {
fn new() -> Self {
Self {
created: Mutex::new(Vec::new()),
find_results: Mutex::new(Vec::new()),
cleanup_count: 0,
fail_all: false,
}
}
fn failing() -> Self {
Self {
created: Mutex::new(Vec::new()),
find_results: Mutex::new(Vec::new()),
cleanup_count: 0,
fail_all: true,
}
}
fn with_find_results(results: Vec<AuditLogEntry>) -> Self {
Self {
created: Mutex::new(Vec::new()),
find_results: Mutex::new(results),
cleanup_count: 0,
fail_all: false,
}
}
fn with_cleanup_count(count: u64) -> Self {
Self {
created: Mutex::new(Vec::new()),
find_results: Mutex::new(Vec::new()),
cleanup_count: count,
fail_all: false,
}
}
}
impl Default for MockAuditLogRepository {
fn default() -> Self {
Self::new()
}
}
#[async_trait]
impl AuditLogRepository for MockAuditLogRepository {
async fn create(
&self,
entry: &AuditLogEntry,
) -> Result<AuditLogEntry, AuditRepositoryError> {
if self.fail_all {
return Err(AuditRepositoryError::DatabaseError(
dbnexus::sea_orm::DbErr::Custom("mock create failure".to_string()).into(),
));
}
self.created
.lock()
.expect("created lock")
.push(entry.clone());
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> {
if self.fail_all {
return Err(AuditRepositoryError::DatabaseError(
dbnexus::sea_orm::DbErr::Custom("mock find failure".to_string()).into(),
));
}
Ok(self.find_results.lock().expect("find lock").clone())
}
async fn find_by_team_id(
&self,
_team_id: crate::domain::id::Id,
_limit: u64,
_offset: u64,
) -> Result<Vec<AuditLogEntry>, AuditRepositoryError> {
if self.fail_all {
return Err(AuditRepositoryError::DatabaseError(
dbnexus::sea_orm::DbErr::Custom("mock find failure".to_string()).into(),
));
}
Ok(self.find_results.lock().expect("find lock").clone())
}
async fn find_denied_for_key(
&self,
_api_key_id: crate::domain::id::Id,
_limit: u64,
) -> Result<Vec<AuditLogEntry>, AuditRepositoryError> {
if self.fail_all {
return Err(AuditRepositoryError::DatabaseError(
dbnexus::sea_orm::DbErr::Custom("mock find failure".to_string()).into(),
));
}
Ok(self.find_results.lock().expect("find lock").clone())
}
async fn cleanup_old_logs(
&self,
_retention_days: i64,
) -> Result<u64, AuditRepositoryError> {
if self.fail_all {
return Err(AuditRepositoryError::DatabaseError(
dbnexus::sea_orm::DbErr::Custom("mock cleanup failure".to_string()).into(),
));
}
Ok(self.cleanup_count)
}
}
fn sample_entry(action: &str, decision: AuditDecision) -> AuditLogEntry {
AuditLogBuilder::new(action, decision)
.with_api_key_id(crate::domain::id::Id::generate())
.with_team_id(crate::domain::id::Id::generate())
.build()
}
#[test]
fn test_audit_service_new_constructs_service() {
let repo: Arc<MockAuditLogRepository> = Arc::new(MockAuditLogRepository::new());
let service = AuditService::new(repo.clone());
let _ = service.audit_repo.clone();
}
#[tokio::test]
async fn test_audit_service_log_success() {
let repo = Arc::new(MockAuditLogRepository::new());
let service = AuditService::new(repo.clone());
let entry = sample_entry("search", AuditDecision::Allow);
let result = service.log(entry.clone()).await;
assert!(result.is_ok());
let created = repo.created.lock().expect("lock");
assert_eq!(created.len(), 1);
assert_eq!(created[0].requested_action, "search");
assert_eq!(created[0].decision, AuditDecision::Allow);
}
#[tokio::test]
async fn test_audit_service_log_repository_error_propagates() {
let repo = Arc::new(MockAuditLogRepository::failing());
let service = AuditService::new(repo);
let entry = sample_entry("search", AuditDecision::Allow);
let result = service.log(entry).await;
assert!(result.is_err());
match result.unwrap_err() {
AuditServiceError::RepositoryError(_) => {}
}
}
#[tokio::test]
async fn test_audit_service_log_allow_builds_allow_entry() {
let repo = Arc::new(MockAuditLogRepository::new());
let service = AuditService::new(repo.clone());
let api_key_id = crate::domain::id::Id::generate();
let team_id = crate::domain::id::Id::generate();
let scope = ApiKeyScope::read_only();
service
.log_allow("scrape.create", api_key_id, team_id, scope.clone())
.await
.expect("log_allow should succeed");
let created = repo.created.lock().expect("lock");
assert_eq!(created.len(), 1);
assert_eq!(created[0].requested_action, "scrape.create");
assert_eq!(created[0].decision, AuditDecision::Allow);
assert_eq!(created[0].api_key_id, Some(api_key_id));
assert_eq!(created[0].team_id, Some(team_id));
assert_eq!(created[0].scope_used, Some(scope));
assert!(created[0].denial_reason.is_none());
}
#[tokio::test]
async fn test_audit_service_log_allow_repository_error() {
let repo = Arc::new(MockAuditLogRepository::failing());
let service = AuditService::new(repo);
let result = service
.log_allow(
"x",
crate::domain::id::Id::generate(),
crate::domain::id::Id::generate(),
ApiKeyScope::default(),
)
.await;
assert!(result.is_err());
}
#[tokio::test]
async fn test_audit_service_log_deny_with_all_fields() {
let repo = Arc::new(MockAuditLogRepository::new());
let service = AuditService::new(repo.clone());
let api_key_id = crate::domain::id::Id::generate();
let team_id = crate::domain::id::Id::generate();
let scope = ApiKeyScope::full_access();
service
.log_deny(
"admin.delete",
Some(api_key_id),
Some(team_id),
"insufficient scope",
Some(scope.clone()),
)
.await
.expect("log_deny should succeed");
let created = repo.created.lock().expect("lock");
assert_eq!(created.len(), 1);
assert_eq!(created[0].requested_action, "admin.delete");
assert_eq!(created[0].decision, AuditDecision::Deny);
assert_eq!(created[0].api_key_id, Some(api_key_id));
assert_eq!(created[0].team_id, Some(team_id));
assert_eq!(
created[0].denial_reason.as_deref(),
Some("insufficient scope")
);
assert_eq!(created[0].scope_used, Some(scope));
}
#[tokio::test]
async fn test_audit_service_log_deny_with_none_fields_preserves_none() {
let repo = Arc::new(MockAuditLogRepository::new());
let service = AuditService::new(repo.clone());
service
.log_deny("anonymous.action", None, None, "auth required", None)
.await
.expect("log_deny should succeed");
let created = repo.created.lock().expect("lock");
assert_eq!(created.len(), 1);
assert_eq!(created[0].decision, AuditDecision::Deny);
assert_eq!(created[0].api_key_id, None);
assert_eq!(created[0].team_id, None);
assert_eq!(created[0].scope_used, None);
assert_eq!(created[0].denial_reason.as_deref(), Some("auth required"));
}
#[tokio::test]
async fn test_audit_service_log_deny_repository_error() {
let repo = Arc::new(MockAuditLogRepository::failing());
let service = AuditService::new(repo);
let result = service
.log_deny("x", None, None, "r".to_string(), None)
.await;
assert!(result.is_err());
}
#[tokio::test]
async fn test_audit_service_get_logs_for_key_returns_results() {
let entry1 = sample_entry("a1", AuditDecision::Allow);
let entry2 = sample_entry("a2", AuditDecision::Deny);
let repo = Arc::new(MockAuditLogRepository::with_find_results(vec![
entry1.clone(),
entry2.clone(),
]));
let service = AuditService::new(repo);
let results = service
.get_logs_for_key(crate::domain::id::Id::generate(), 10, 0)
.await
.expect("get_logs_for_key should succeed");
assert_eq!(results.len(), 2);
assert_eq!(results[0].requested_action, "a1");
assert_eq!(results[1].requested_action, "a2");
}
#[tokio::test]
async fn test_audit_service_get_logs_for_key_empty() {
let repo = Arc::new(MockAuditLogRepository::new());
let service = AuditService::new(repo);
let results = service
.get_logs_for_key(crate::domain::id::Id::generate(), 10, 0)
.await
.expect("should succeed");
assert!(results.is_empty());
}
#[tokio::test]
async fn test_audit_service_get_logs_for_key_repository_error() {
let repo = Arc::new(MockAuditLogRepository::failing());
let service = AuditService::new(repo);
let result = service
.get_logs_for_key(crate::domain::id::Id::generate(), 10, 0)
.await;
assert!(result.is_err());
}
#[tokio::test]
async fn test_audit_service_get_logs_for_team_returns_results() {
let entry = sample_entry("team_action", AuditDecision::Allow);
let repo = Arc::new(MockAuditLogRepository::with_find_results(vec![
entry.clone()
]));
let service = AuditService::new(repo);
let results = service
.get_logs_for_team(crate::domain::id::Id::generate(), 50, 10)
.await
.expect("get_logs_for_team should succeed");
assert_eq!(results.len(), 1);
assert_eq!(results[0].requested_action, "team_action");
}
#[tokio::test]
async fn test_audit_service_get_logs_for_team_repository_error() {
let repo = Arc::new(MockAuditLogRepository::failing());
let service = AuditService::new(repo);
let result = service
.get_logs_for_team(crate::domain::id::Id::generate(), 50, 0)
.await;
assert!(result.is_err());
}
#[tokio::test]
async fn test_audit_service_get_denied_requests_returns_only_denied() {
let denied1 = sample_entry("blocked1", AuditDecision::Deny);
let denied2 = sample_entry("blocked2", AuditDecision::Deny);
let repo = Arc::new(MockAuditLogRepository::with_find_results(vec![
denied1.clone(),
denied2.clone(),
]));
let service = AuditService::new(repo);
let results = service
.get_denied_requests(crate::domain::id::Id::generate(), 100)
.await
.expect("get_denied_requests should succeed");
assert_eq!(results.len(), 2);
assert!(results.iter().all(|r| r.decision == AuditDecision::Deny));
}
#[tokio::test]
async fn test_audit_service_get_denied_requests_empty() {
let repo = Arc::new(MockAuditLogRepository::new());
let service = AuditService::new(repo);
let results = service
.get_denied_requests(crate::domain::id::Id::generate(), 100)
.await
.expect("should succeed");
assert!(results.is_empty());
}
#[tokio::test]
async fn test_audit_service_get_denied_requests_repository_error() {
let repo = Arc::new(MockAuditLogRepository::failing());
let service = AuditService::new(repo);
let result = service
.get_denied_requests(crate::domain::id::Id::generate(), 100)
.await;
assert!(result.is_err());
}
#[tokio::test]
async fn test_audit_service_cleanup_old_logs_returns_count() {
let repo = Arc::new(MockAuditLogRepository::with_cleanup_count(42));
let service = AuditService::new(repo);
let count = service
.cleanup_old_logs(90)
.await
.expect("cleanup_old_logs should succeed");
assert_eq!(count, 42);
}
#[tokio::test]
async fn test_audit_service_cleanup_old_logs_zero() {
let repo = Arc::new(MockAuditLogRepository::new());
let service = AuditService::new(repo);
let count = service.cleanup_old_logs(30).await.expect("should succeed");
assert_eq!(count, 0);
}
#[tokio::test]
async fn test_audit_service_cleanup_old_logs_repository_error() {
let repo = Arc::new(MockAuditLogRepository::failing());
let service = AuditService::new(repo);
let result = service.cleanup_old_logs(30).await;
assert!(result.is_err());
}
#[tokio::test]
async fn test_audit_service_trait_log_delegates_to_log() {
let repo = Arc::new(MockAuditLogRepository::new());
let service: AuditService<MockAuditLogRepository> = AuditService::new(repo.clone());
let entry = sample_entry("trait_action", AuditDecision::Allow);
let result = AuditServiceTrait::log(&service, entry.clone()).await;
assert!(result.is_ok());
let created = repo.created.lock().expect("lock");
assert_eq!(created.len(), 1);
assert_eq!(created[0].requested_action, "trait_action");
}
#[tokio::test]
async fn test_audit_service_trait_log_allow() {
let repo = Arc::new(MockAuditLogRepository::new());
let service: AuditService<MockAuditLogRepository> = AuditService::new(repo.clone());
let result = AuditServiceTrait::log_allow(
&service,
"trait.allow".to_string(),
crate::domain::id::Id::generate(),
crate::domain::id::Id::generate(),
ApiKeyScope::default(),
)
.await;
assert!(result.is_ok());
let created = repo.created.lock().expect("lock");
assert_eq!(created[0].requested_action, "trait.allow");
assert_eq!(created[0].decision, AuditDecision::Allow);
}
#[tokio::test]
async fn test_audit_service_trait_log_deny() {
let repo = Arc::new(MockAuditLogRepository::new());
let service: AuditService<MockAuditLogRepository> = AuditService::new(repo.clone());
let result = AuditServiceTrait::log_deny(
&service,
"trait.deny".to_string(),
None,
None,
"nope".to_string(),
None,
)
.await;
assert!(result.is_ok());
let created = repo.created.lock().expect("lock");
assert_eq!(created[0].requested_action, "trait.deny");
assert_eq!(created[0].decision, AuditDecision::Deny);
assert_eq!(created[0].denial_reason.as_deref(), Some("nope"));
}
#[tokio::test]
async fn test_audit_service_trait_get_logs_for_key() {
let entry = sample_entry("k", AuditDecision::Allow);
let repo = Arc::new(MockAuditLogRepository::with_find_results(vec![entry]));
let service: AuditService<MockAuditLogRepository> = AuditService::new(repo);
let results =
AuditServiceTrait::get_logs_for_key(&service, crate::domain::id::Id::generate(), 5, 0)
.await
.expect("trait get_logs_for_key should succeed");
assert_eq!(results.len(), 1);
}
#[tokio::test]
async fn test_audit_service_trait_get_logs_for_team() {
let repo = Arc::new(MockAuditLogRepository::new());
let service: AuditService<MockAuditLogRepository> = AuditService::new(repo);
let results =
AuditServiceTrait::get_logs_for_team(&service, crate::domain::id::Id::generate(), 5, 0)
.await
.expect("trait get_logs_for_team should succeed");
assert!(results.is_empty());
}
#[tokio::test]
async fn test_audit_service_trait_get_denied_requests() {
let repo = Arc::new(MockAuditLogRepository::new());
let service: AuditService<MockAuditLogRepository> = AuditService::new(repo);
let results =
AuditServiceTrait::get_denied_requests(&service, crate::domain::id::Id::generate(), 5)
.await
.expect("trait get_denied_requests should succeed");
assert!(results.is_empty());
}
#[test]
fn test_audit_service_error_from_repository_db_error_to_app_error() {
let repo_err = AuditRepositoryError::DatabaseError(
dbnexus::sea_orm::DbErr::Custom("repo db failure".to_string()).into(),
);
let service_err: AuditServiceError = repo_err.into();
let app_err: CrawlRsError = service_err.into();
match app_err {
CrawlRsError::Database(_) => {}
other => panic!("expected CrawlRsError::Database, got {:?}", other),
}
}
#[test]
fn test_audit_service_error_from_repository_not_found_to_app_error_other() {
let repo_err = AuditRepositoryError::NotFound;
let service_err: AuditServiceError = repo_err.into();
let app_err: CrawlRsError = service_err.into();
match app_err {
CrawlRsError::Other(msg) => {
assert!(msg.contains("Audit log not found"), "msg was: {}", msg);
}
other => panic!("expected CrawlRsError::Other, got {:?}", other),
}
}
#[test]
fn test_audit_service_error_display_repository() {
let err = AuditServiceError::RepositoryError(AuditRepositoryError::NotFound);
let msg = format!("{}", err);
assert!(msg.contains("Repository error"));
assert!(msg.contains("Audit log not found"));
}
#[test]
fn test_audit_log_entry_getters_return_set_values() {
let ip: std::net::IpAddr = Ipv4Addr::new(192, 168, 0, 1).into();
let trace_id = crate::domain::id::Id::generate();
let entry = AuditLogBuilder::new("action", AuditDecision::Allow)
.with_ip_address(ip)
.with_trace_id(trace_id)
.with_user_agent("Agent/1.0")
.with_request_path("/path")
.with_request_method("POST")
.build();
assert_eq!(entry.ip_address(), Some(ip));
assert_eq!(entry.trace_id(), Some(trace_id));
assert_eq!(entry.user_agent(), Some("Agent/1.0"));
assert_eq!(entry.request_path(), Some("/path"));
assert_eq!(entry.request_method(), Some("POST"));
}
#[test]
fn test_audit_log_entry_getters_return_none_when_unset() {
let entry = AuditLogBuilder::new("action", AuditDecision::Allow).build();
assert!(entry.ip_address().is_none());
assert!(entry.trace_id().is_none());
assert!(entry.user_agent().is_none());
assert!(entry.request_path().is_none());
assert!(entry.request_method().is_none());
}
use crate::test_utils::ensure_debug_logger;
#[tokio::test]
async fn test_audit_service_log_with_logger_covers_debug_macro_args() {
ensure_debug_logger();
let repo = Arc::new(MockAuditLogRepository::new());
let service = AuditService::new(repo.clone());
let entry = sample_entry("search", AuditDecision::Allow);
let result = service.log(entry).await;
assert!(result.is_ok());
let created = repo.created.lock().expect("lock");
assert_eq!(created.len(), 1);
}
#[tokio::test]
async fn test_audit_service_log_deny_with_logger_covers_debug_macro_args() {
ensure_debug_logger();
let repo = Arc::new(MockAuditLogRepository::new());
let service = AuditService::new(repo.clone());
let api_key_id = crate::domain::id::Id::generate();
let team_id = crate::domain::id::Id::generate();
let scope = ApiKeyScope::read_only();
service
.log_deny(
"scrape.create".to_string(),
Some(api_key_id),
Some(team_id),
"denied for test".to_string(),
Some(scope),
)
.await
.expect("log_deny should succeed");
let created = repo.created.lock().expect("lock");
assert_eq!(created.len(), 1);
assert_eq!(created[0].decision, AuditDecision::Deny);
}
}
#[async_trait::async_trait]
pub trait AuditServiceTrait: Send + Sync {
async fn log(&self, entry: AuditLogEntry) -> Result<(), AuditServiceError>;
async fn log_allow(
&self,
action: String,
api_key_id: crate::domain::id::Id,
team_id: crate::domain::id::Id,
scope: ApiKeyScope,
) -> Result<(), AuditServiceError>;
async fn log_deny(
&self,
action: String,
api_key_id: Option<crate::domain::id::Id>,
team_id: Option<crate::domain::id::Id>,
reason: String,
scope: Option<ApiKeyScope>,
) -> Result<(), AuditServiceError>;
async fn get_logs_for_key(
&self,
api_key_id: crate::domain::id::Id,
limit: u64,
offset: u64,
) -> Result<Vec<AuditLogEntry>, AuditServiceError>;
async fn get_logs_for_team(
&self,
team_id: crate::domain::id::Id,
limit: u64,
offset: u64,
) -> Result<Vec<AuditLogEntry>, AuditServiceError>;
async fn get_denied_requests(
&self,
api_key_id: crate::domain::id::Id,
limit: u64,
) -> Result<Vec<AuditLogEntry>, AuditServiceError>;
}
#[derive(Clone)]
pub struct AuditService<R: AuditLogRepository> {
audit_repo: Arc<R>,
}
impl<R: AuditLogRepository> AuditService<R> {
pub fn new(audit_repo: Arc<R>) -> Self {
Self { audit_repo }
}
pub async fn log_internal(&self, entry: AuditLogEntry) -> Result<(), AuditServiceError> {
debug!(
"Creating audit log: action={}, decision={}",
entry.requested_action, entry.decision
);
self.audit_repo
.create(&entry)
.await
.map(|_| ())
.map_err(Into::into)
}
pub async fn log_allow_internal(
&self,
action: impl Into<String>,
api_key_id: crate::domain::id::Id,
team_id: crate::domain::id::Id,
scope: ApiKeyScope,
) -> Result<(), AuditServiceError> {
let entry = AuditLogBuilder::new(action, AuditDecision::Allow)
.with_api_key_id(api_key_id)
.with_team_id(team_id)
.with_scope(scope)
.build();
self.log_internal(entry).await
}
pub async fn log_deny_internal(
&self,
action: impl Into<String>,
api_key_id: Option<crate::domain::id::Id>,
team_id: Option<crate::domain::id::Id>,
reason: impl Into<String>,
scope: Option<ApiKeyScope>,
) -> Result<(), AuditServiceError> {
let entry = AuditLogBuilder::new(action, AuditDecision::Deny)
.maybe_with_api_key_id(api_key_id)
.maybe_with_team_id(team_id)
.with_denial_reason(reason)
.maybe_with_scope(scope)
.build();
self.log_internal(entry).await
}
pub async fn log(&self, entry: AuditLogEntry) -> Result<(), AuditServiceError> {
self.log_internal(entry).await
}
pub async fn log_allow(
&self,
action: impl Into<String>,
api_key_id: crate::domain::id::Id,
team_id: crate::domain::id::Id,
scope: ApiKeyScope,
) -> Result<(), AuditServiceError> {
self.log_allow_internal(action, api_key_id, team_id, scope)
.await
}
pub async fn log_deny(
&self,
action: impl Into<String>,
api_key_id: Option<crate::domain::id::Id>,
team_id: Option<crate::domain::id::Id>,
reason: impl Into<String>,
scope: Option<ApiKeyScope>,
) -> Result<(), AuditServiceError> {
self.log_deny_internal(action, api_key_id, team_id, reason, scope)
.await
}
pub async fn get_logs_for_key(
&self,
api_key_id: crate::domain::id::Id,
limit: u64,
offset: u64,
) -> Result<Vec<AuditLogEntry>, AuditServiceError> {
self.audit_repo
.find_by_api_key_id(api_key_id, limit, offset)
.await
.map_err(Into::into)
}
pub async fn get_logs_for_team(
&self,
team_id: crate::domain::id::Id,
limit: u64,
offset: u64,
) -> Result<Vec<AuditLogEntry>, AuditServiceError> {
self.audit_repo
.find_by_team_id(team_id, limit, offset)
.await
.map_err(Into::into)
}
pub async fn get_denied_requests(
&self,
api_key_id: crate::domain::id::Id,
limit: u64,
) -> Result<Vec<AuditLogEntry>, AuditServiceError> {
self.audit_repo
.find_denied_for_key(api_key_id, limit)
.await
.map_err(Into::into)
}
pub async fn cleanup_old_logs(&self, retention_days: i64) -> Result<u64, AuditServiceError> {
self.audit_repo
.cleanup_old_logs(retention_days)
.await
.map_err(Into::into)
}
}
#[async_trait::async_trait]
impl<R: AuditLogRepository + 'static> AuditServiceTrait for AuditService<R> {
async fn log(&self, entry: AuditLogEntry) -> Result<(), AuditServiceError> {
self.log_internal(entry).await
}
async fn log_allow(
&self,
action: String,
api_key_id: crate::domain::id::Id,
team_id: crate::domain::id::Id,
scope: ApiKeyScope,
) -> Result<(), AuditServiceError> {
self.log_allow_internal(action, api_key_id, team_id, scope)
.await
}
async fn log_deny(
&self,
action: String,
api_key_id: Option<crate::domain::id::Id>,
team_id: Option<crate::domain::id::Id>,
reason: String,
scope: Option<ApiKeyScope>,
) -> Result<(), AuditServiceError> {
self.log_deny_internal(action, api_key_id, team_id, reason, scope)
.await
}
async fn get_logs_for_key(
&self,
api_key_id: crate::domain::id::Id,
limit: u64,
offset: u64,
) -> Result<Vec<AuditLogEntry>, AuditServiceError> {
self.audit_repo
.find_by_api_key_id(api_key_id, limit, offset)
.await
.map_err(Into::into)
}
async fn get_logs_for_team(
&self,
team_id: crate::domain::id::Id,
limit: u64,
offset: u64,
) -> Result<Vec<AuditLogEntry>, AuditServiceError> {
self.audit_repo
.find_by_team_id(team_id, limit, offset)
.await
.map_err(Into::into)
}
async fn get_denied_requests(
&self,
api_key_id: crate::domain::id::Id,
limit: u64,
) -> Result<Vec<AuditLogEntry>, AuditServiceError> {
self.audit_repo
.find_denied_for_key(api_key_id, limit)
.await
.map_err(Into::into)
}
}