1use async_trait::async_trait;
9use serde::{Deserialize, Serialize};
10use std::collections::HashMap;
11use std::sync::Arc;
12use tokio::sync::RwLock;
13use tracing::{debug, info};
14
15#[derive(Debug, thiserror::Error)]
19pub enum StorageError {
20 #[error("Database error: {0}")]
21 Database(String),
22 #[error("Serialization error: {0}")]
23 Serialization(String),
24 #[error("Not found: {0}")]
25 NotFound(String),
26}
27
28pub type StorageResult<T> = Result<T, StorageError>;
30
31#[derive(Debug, Clone, Serialize, Deserialize)]
35pub struct StoredRole {
36 pub id: String,
37 pub name: String,
38 pub description: Option<String>,
39 pub permissions: Vec<StoredPermission>,
40}
41
42#[derive(Debug, Clone, Serialize, Deserialize)]
44pub struct StoredPermission {
45 pub action: String,
46 pub resource: String,
47 pub instance: Option<String>,
48}
49
50#[derive(Debug, Clone, Serialize, Deserialize)]
52pub struct RoleAssignment {
53 pub user_id: String,
54 pub role_id: String,
55 pub assigned_by: Option<String>,
56 pub expires_at: Option<chrono::DateTime<chrono::Utc>>,
57}
58
59#[derive(Debug, Clone, Serialize, Deserialize)]
61pub struct AuditEntry {
62 pub user_id: Option<String>,
63 pub action: String,
64 pub resource: Option<String>,
65 pub result: String,
66 pub context: HashMap<String, String>,
67}
68
69impl StoredRole {
72 pub fn to_role_system(&self) -> role_system::Role {
74 let mut role = role_system::Role::with_id(&self.id, &self.name);
75 if let Some(ref desc) = self.description {
76 role = role.with_description(desc);
77 }
78 for perm in &self.permissions {
79 role = role.add_permission(perm.to_role_system());
80 }
81 role
82 }
83
84 pub fn from_role_system(role: &role_system::Role) -> Self {
86 Self {
87 id: role.id().to_string(),
88 name: role.name().to_string(),
89 description: role.description().map(|s| s.to_string()),
90 permissions: role
91 .permissions()
92 .permissions()
93 .iter()
94 .map(StoredPermission::from_role_system)
95 .collect(),
96 }
97 }
98}
99
100impl StoredPermission {
101 pub fn to_role_system(&self) -> role_system::Permission {
103 if let Some(ref instance) = self.instance {
104 role_system::Permission::with_instance(&self.action, &self.resource, instance)
105 } else {
106 role_system::Permission::new(&self.action, &self.resource)
107 }
108 }
109
110 pub fn from_role_system(perm: &role_system::Permission) -> Self {
112 Self {
113 action: perm.action().to_string(),
114 resource: perm.resource_type().to_string(),
115 instance: perm.instance().map(|s| s.to_string()),
116 }
117 }
118}
119
120#[async_trait]
124pub trait RoleStorage: Send + Sync {
125 async fn create_role(&self, role: &StoredRole) -> StorageResult<()>;
126 async fn update_role(&self, role: &StoredRole) -> StorageResult<()>;
127 async fn delete_role(&self, role_id: &str) -> StorageResult<()>;
128 async fn get_role(&self, role_id: &str) -> StorageResult<Option<StoredRole>>;
129 async fn list_roles(&self) -> StorageResult<Vec<StoredRole>>;
130
131 async fn store_permission(&self, id: &str, permission: &StoredPermission) -> StorageResult<()>;
132 async fn get_permission(&self, permission_id: &str) -> StorageResult<Option<StoredPermission>>;
133
134 async fn assign_role(&self, assignment: &RoleAssignment) -> StorageResult<()>;
135 async fn revoke_role(&self, user_id: &str, role_id: &str) -> StorageResult<()>;
136 async fn get_user_roles(&self, user_id: &str) -> StorageResult<Vec<String>>;
137 async fn get_role_permissions(&self, role_id: &str) -> StorageResult<Vec<String>>;
138
139 async fn log_audit_entry(&self, entry: &AuditEntry) -> StorageResult<()>;
140}
141
142pub struct DatabaseStorage {
146 connection: Arc<dyn DatabaseConnection>,
147 role_cache: Arc<RwLock<HashMap<String, StoredRole>>>,
148 permission_cache: Arc<RwLock<HashMap<String, StoredPermission>>>,
149 cache_ttl: u64,
150}
151
152#[async_trait]
154pub trait DatabaseConnection: Send + Sync {
155 async fn execute_query(
156 &self,
157 query: &str,
158 params: &[&dyn DatabaseValue],
159 ) -> Result<QueryResult, DatabaseError>;
160 async fn fetch_one(
161 &self,
162 query: &str,
163 params: &[&dyn DatabaseValue],
164 ) -> Result<Row, DatabaseError>;
165 async fn fetch_all(
166 &self,
167 query: &str,
168 params: &[&dyn DatabaseValue],
169 ) -> Result<Vec<Row>, DatabaseError>;
170}
171
172pub trait DatabaseValue: Send + Sync {
174 fn as_str(&self) -> Option<&str>;
175 fn as_i64(&self) -> Option<i64>;
176 fn as_bool(&self) -> Option<bool>;
177}
178
179impl DatabaseValue for String {
180 fn as_str(&self) -> Option<&str> {
181 Some(self.as_ref())
182 }
183 fn as_i64(&self) -> Option<i64> {
184 None
185 }
186 fn as_bool(&self) -> Option<bool> {
187 None
188 }
189}
190
191impl DatabaseValue for &str {
192 fn as_str(&self) -> Option<&str> {
193 Some(self)
194 }
195 fn as_i64(&self) -> Option<i64> {
196 None
197 }
198 fn as_bool(&self) -> Option<bool> {
199 None
200 }
201}
202
203impl DatabaseValue for Option<&str> {
204 fn as_str(&self) -> Option<&str> {
205 *self
206 }
207 fn as_i64(&self) -> Option<i64> {
208 None
209 }
210 fn as_bool(&self) -> Option<bool> {
211 None
212 }
213}
214
215impl DatabaseValue for i64 {
216 fn as_str(&self) -> Option<&str> {
217 None
218 }
219 fn as_i64(&self) -> Option<i64> {
220 Some(*self)
221 }
222 fn as_bool(&self) -> Option<bool> {
223 None
224 }
225}
226
227impl DatabaseValue for bool {
228 fn as_str(&self) -> Option<&str> {
229 None
230 }
231 fn as_i64(&self) -> Option<i64> {
232 None
233 }
234 fn as_bool(&self) -> Option<bool> {
235 Some(*self)
236 }
237}
238
239#[derive(Debug)]
241pub struct QueryResult {
242 pub rows_affected: u64,
243}
244
245#[derive(Debug)]
247pub struct Row {
248 pub columns: HashMap<String, DatabaseColumnValue>,
249}
250
251#[derive(Clone)]
253pub enum DatabaseColumnValue {
254 String(String),
255 Integer(i64),
256 Boolean(bool),
257 Null,
258}
259
260impl std::fmt::Debug for DatabaseColumnValue {
261 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
262 match self {
263 Self::String(v) => f
265 .debug_tuple("String")
266 .field(&crate::utils::redact::redacted(v))
267 .finish(),
268 Self::Integer(v) => f.debug_tuple("Integer").field(v).finish(),
269 Self::Boolean(v) => f.debug_tuple("Boolean").field(v).finish(),
270 Self::Null => f.write_str("Null"),
271 }
272 }
273}
274
275#[derive(Debug, thiserror::Error)]
277pub enum DatabaseError {
278 #[error("Connection error: {0}")]
279 Connection(String),
280 #[error("Query error: {0}")]
281 Query(String),
282 #[error("Serialization error: {0}")]
283 Serialization(String),
284}
285
286impl DatabaseStorage {
287 pub fn new(connection: Arc<dyn DatabaseConnection>) -> Self {
289 Self {
290 connection,
291 role_cache: Arc::new(RwLock::new(HashMap::new())),
292 permission_cache: Arc::new(RwLock::new(HashMap::new())),
293 cache_ttl: 300, }
295 }
296
297 pub fn with_cache_ttl(mut self, ttl_seconds: u64) -> Self {
299 self.cache_ttl = ttl_seconds;
300 self
301 }
302
303 pub async fn initialize_schema(&self) -> Result<(), DatabaseError> {
305 self.connection
306 .execute_query(
307 r#"CREATE TABLE IF NOT EXISTS roles (
308 id VARCHAR(255) PRIMARY KEY,
309 name VARCHAR(255) NOT NULL UNIQUE,
310 description TEXT,
311 created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
312 updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
313 )"#,
314 &[],
315 )
316 .await?;
317
318 self.connection
319 .execute_query(
320 r#"CREATE TABLE IF NOT EXISTS permissions (
321 id VARCHAR(255) PRIMARY KEY,
322 action VARCHAR(255) NOT NULL,
323 resource VARCHAR(255) NOT NULL,
324 instance VARCHAR(255),
325 created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
326 UNIQUE(action, resource)
327 )"#,
328 &[],
329 )
330 .await?;
331
332 self.connection
333 .execute_query(
334 r#"CREATE TABLE IF NOT EXISTS role_permissions (
335 role_id VARCHAR(255),
336 permission_id VARCHAR(255),
337 granted_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
338 PRIMARY KEY (role_id, permission_id),
339 FOREIGN KEY (role_id) REFERENCES roles(id) ON DELETE CASCADE,
340 FOREIGN KEY (permission_id) REFERENCES permissions(id) ON DELETE CASCADE
341 )"#,
342 &[],
343 )
344 .await?;
345
346 self.connection
347 .execute_query(
348 r#"CREATE TABLE IF NOT EXISTS user_roles (
349 user_id VARCHAR(255),
350 role_id VARCHAR(255),
351 assigned_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
352 assigned_by VARCHAR(255),
353 expires_at TIMESTAMP NULL,
354 PRIMARY KEY (user_id, role_id),
355 FOREIGN KEY (role_id) REFERENCES roles(id) ON DELETE CASCADE
356 )"#,
357 &[],
358 )
359 .await?;
360
361 self.connection
362 .execute_query(
363 r#"CREATE TABLE IF NOT EXISTS audit_log (
364 id BIGINT PRIMARY KEY AUTO_INCREMENT,
365 user_id VARCHAR(255),
366 action VARCHAR(255) NOT NULL,
367 resource VARCHAR(255),
368 result VARCHAR(50) NOT NULL,
369 context TEXT,
370 timestamp TIMESTAMP DEFAULT CURRENT_TIMESTAMP
371 )"#,
372 &[],
373 )
374 .await?;
375
376 info!("Database schema initialized successfully");
377 Ok(())
378 }
379
380 async fn clear_caches(&self) {
382 self.role_cache.write().await.clear();
383 self.permission_cache.write().await.clear();
384 debug!("Cleared authorization caches");
385 }
386
387 fn row_to_stored_role(&self, row: &Row) -> StorageResult<StoredRole> {
388 let id = self.get_string_column(row, "id")?;
389 let name = self.get_string_column(row, "name")?;
390 let description = self.get_optional_string_column(row, "description");
391 Ok(StoredRole {
392 id,
393 name,
394 description,
395 permissions: Vec::new(), })
397 }
398
399 fn row_to_stored_permission(&self, row: &Row) -> StorageResult<StoredPermission> {
400 let action = self.get_string_column(row, "action")?;
401 let resource = self.get_string_column(row, "resource")?;
402 let instance = self.get_optional_string_column(row, "instance");
403 Ok(StoredPermission {
404 action,
405 resource,
406 instance,
407 })
408 }
409
410 fn get_string_column(&self, row: &Row, column: &str) -> StorageResult<String> {
411 match row.columns.get(column) {
412 Some(DatabaseColumnValue::String(value)) => Ok(value.clone()),
413 Some(DatabaseColumnValue::Null) => {
414 Err(StorageError::Database(format!("Column {column} is null")))
415 }
416 Some(_) => Err(StorageError::Database(format!(
417 "Column {column} is not a string"
418 ))),
419 None => Err(StorageError::Database(format!("Column {column} not found"))),
420 }
421 }
422
423 fn get_optional_string_column(&self, row: &Row, column: &str) -> Option<String> {
424 match row.columns.get(column) {
425 Some(DatabaseColumnValue::String(value)) => Some(value.clone()),
426 _ => None,
427 }
428 }
429}
430
431#[async_trait]
432impl RoleStorage for DatabaseStorage {
433 async fn create_role(&self, role: &StoredRole) -> StorageResult<()> {
434 self.connection
435 .execute_query(
436 "INSERT INTO roles (id, name, description) VALUES (?, ?, ?)",
437 &[
438 &role.id as &dyn DatabaseValue,
439 &role.name as &dyn DatabaseValue,
440 &role.description.as_deref().unwrap_or("") as &dyn DatabaseValue,
441 ],
442 )
443 .await
444 .map_err(|e| StorageError::Database(e.to_string()))?;
445 self.clear_caches().await;
446 info!("Created role: {}", role.name);
447 Ok(())
448 }
449
450 async fn update_role(&self, role: &StoredRole) -> StorageResult<()> {
451 self.connection
452 .execute_query(
453 "UPDATE roles SET name = ?, description = ?, updated_at = CURRENT_TIMESTAMP WHERE id = ?",
454 &[
455 &role.name as &dyn DatabaseValue,
456 &role.description.as_deref().unwrap_or("") as &dyn DatabaseValue,
457 &role.id as &dyn DatabaseValue,
458 ],
459 )
460 .await
461 .map_err(|e| StorageError::Database(e.to_string()))?;
462 self.role_cache
463 .write()
464 .await
465 .insert(role.id.clone(), role.clone());
466 info!("Updated role: {}", role.name);
467 Ok(())
468 }
469
470 async fn delete_role(&self, role_id: &str) -> StorageResult<()> {
471 self.connection
472 .execute_query(
473 "DELETE FROM roles WHERE id = ?",
474 &[&role_id as &dyn DatabaseValue],
475 )
476 .await
477 .map_err(|e| StorageError::Database(e.to_string()))?;
478 self.role_cache.write().await.remove(role_id);
479 info!("Deleted role: {}", role_id);
480 Ok(())
481 }
482
483 async fn get_role(&self, role_id: &str) -> StorageResult<Option<StoredRole>> {
484 {
485 let cache = self.role_cache.read().await;
486 if let Some(role) = cache.get(role_id) {
487 return Ok(Some(role.clone()));
488 }
489 }
490 let row = match self
491 .connection
492 .fetch_one(
493 "SELECT id, name, description FROM roles WHERE id = ?",
494 &[&role_id as &dyn DatabaseValue],
495 )
496 .await
497 {
498 Ok(row) => row,
499 Err(DatabaseError::Query(_)) => return Ok(None),
500 Err(e) => return Err(StorageError::Database(e.to_string())),
501 };
502 let role = self.row_to_stored_role(&row)?;
503 self.role_cache
504 .write()
505 .await
506 .insert(role_id.to_string(), role.clone());
507 Ok(Some(role))
508 }
509
510 async fn list_roles(&self) -> StorageResult<Vec<StoredRole>> {
511 let rows = self
512 .connection
513 .fetch_all("SELECT id, name, description FROM roles ORDER BY name", &[])
514 .await
515 .map_err(|e| StorageError::Database(e.to_string()))?;
516 rows.iter().map(|r| self.row_to_stored_role(r)).collect()
517 }
518
519 async fn store_permission(&self, id: &str, permission: &StoredPermission) -> StorageResult<()> {
520 self.connection
521 .execute_query(
522 "INSERT INTO permissions (id, action, resource, instance) VALUES (?, ?, ?, ?)",
523 &[
524 &id as &dyn DatabaseValue,
525 &permission.action as &dyn DatabaseValue,
526 &permission.resource as &dyn DatabaseValue,
527 &permission.instance.as_deref() as &dyn DatabaseValue,
528 ],
529 )
530 .await
531 .map_err(|e| StorageError::Database(e.to_string()))?;
532 self.permission_cache
533 .write()
534 .await
535 .insert(id.to_string(), permission.clone());
536 info!(
537 "Created permission: {}:{}",
538 permission.action, permission.resource
539 );
540 Ok(())
541 }
542
543 async fn get_permission(&self, permission_id: &str) -> StorageResult<Option<StoredPermission>> {
544 {
545 let cache = self.permission_cache.read().await;
546 if let Some(p) = cache.get(permission_id) {
547 return Ok(Some(p.clone()));
548 }
549 }
550 let row = match self
551 .connection
552 .fetch_one(
553 "SELECT action, resource, instance FROM permissions WHERE id = ?",
554 &[&permission_id as &dyn DatabaseValue],
555 )
556 .await
557 {
558 Ok(row) => row,
559 Err(DatabaseError::Query(_)) => return Ok(None),
560 Err(e) => return Err(StorageError::Database(e.to_string())),
561 };
562 let perm = self.row_to_stored_permission(&row)?;
563 self.permission_cache
564 .write()
565 .await
566 .insert(permission_id.to_string(), perm.clone());
567 Ok(Some(perm))
568 }
569
570 async fn assign_role(&self, assignment: &RoleAssignment) -> StorageResult<()> {
571 self.connection
572 .execute_query(
573 "INSERT OR REPLACE INTO user_roles (user_id, role_id, assigned_by) VALUES (?, ?, ?)",
574 &[
575 &assignment.user_id as &dyn DatabaseValue,
576 &assignment.role_id as &dyn DatabaseValue,
577 &assignment.assigned_by.as_deref() as &dyn DatabaseValue,
578 ],
579 )
580 .await
581 .map_err(|e| StorageError::Database(e.to_string()))?;
582 info!(
583 "Assigned role {} to user {}",
584 assignment.role_id, assignment.user_id
585 );
586 Ok(())
587 }
588
589 async fn revoke_role(&self, user_id: &str, role_id: &str) -> StorageResult<()> {
590 self.connection
591 .execute_query(
592 "DELETE FROM user_roles WHERE user_id = ? AND role_id = ?",
593 &[
594 &user_id as &dyn DatabaseValue,
595 &role_id as &dyn DatabaseValue,
596 ],
597 )
598 .await
599 .map_err(|e| StorageError::Database(e.to_string()))?;
600 info!("Revoked role {} from user {}", role_id, user_id);
601 Ok(())
602 }
603
604 async fn get_user_roles(&self, user_id: &str) -> StorageResult<Vec<String>> {
605 let rows = self
606 .connection
607 .fetch_all(
608 "SELECT role_id FROM user_roles WHERE user_id = ? AND (expires_at IS NULL OR expires_at > CURRENT_TIMESTAMP)",
609 &[&user_id as &dyn DatabaseValue],
610 )
611 .await
612 .map_err(|e| StorageError::Database(e.to_string()))?;
613 Ok(rows
614 .iter()
615 .filter_map(|r| match r.columns.get("role_id") {
616 Some(DatabaseColumnValue::String(s)) => Some(s.clone()),
617 _ => None,
618 })
619 .collect())
620 }
621
622 async fn get_role_permissions(&self, role_id: &str) -> StorageResult<Vec<String>> {
623 let rows = self
624 .connection
625 .fetch_all(
626 "SELECT permission_id FROM role_permissions WHERE role_id = ?",
627 &[&role_id as &dyn DatabaseValue],
628 )
629 .await
630 .map_err(|e| StorageError::Database(e.to_string()))?;
631 Ok(rows
632 .iter()
633 .filter_map(|r| match r.columns.get("permission_id") {
634 Some(DatabaseColumnValue::String(s)) => Some(s.clone()),
635 _ => None,
636 })
637 .collect())
638 }
639
640 async fn log_audit_entry(&self, entry: &AuditEntry) -> StorageResult<()> {
641 let context_json = serde_json::to_string(&entry.context)
642 .map_err(|e| StorageError::Serialization(e.to_string()))?;
643 self.connection
644 .execute_query(
645 "INSERT INTO audit_log (user_id, action, resource, result, context) VALUES (?, ?, ?, ?, ?)",
646 &[
647 &entry.user_id.as_deref() as &dyn DatabaseValue,
648 &entry.action as &dyn DatabaseValue,
649 &entry.resource.as_deref() as &dyn DatabaseValue,
650 &entry.result as &dyn DatabaseValue,
651 &context_json as &dyn DatabaseValue,
652 ],
653 )
654 .await
655 .map_err(|e| StorageError::Database(e.to_string()))?;
656 debug!(
657 "Logged audit entry for user {:?}: {}",
658 entry.user_id, entry.action
659 );
660 Ok(())
661 }
662}
663
664pub struct MemoryRbacStorage {
668 roles: Arc<RwLock<HashMap<String, StoredRole>>>,
669 permissions: Arc<RwLock<HashMap<String, StoredPermission>>>,
670 user_roles: Arc<RwLock<HashMap<String, Vec<String>>>>,
671 role_permissions: Arc<RwLock<HashMap<String, Vec<String>>>>,
672 audit_log: Arc<RwLock<Vec<AuditEntry>>>,
673}
674
675impl Default for MemoryRbacStorage {
676 fn default() -> Self {
677 Self::new()
678 }
679}
680
681impl MemoryRbacStorage {
682 pub fn new() -> Self {
683 Self {
684 roles: Arc::new(RwLock::new(HashMap::new())),
685 permissions: Arc::new(RwLock::new(HashMap::new())),
686 user_roles: Arc::new(RwLock::new(HashMap::new())),
687 role_permissions: Arc::new(RwLock::new(HashMap::new())),
688 audit_log: Arc::new(RwLock::new(Vec::new())),
689 }
690 }
691
692 pub async fn clear(&self) {
694 self.roles.write().await.clear();
695 self.permissions.write().await.clear();
696 self.user_roles.write().await.clear();
697 self.role_permissions.write().await.clear();
698 self.audit_log.write().await.clear();
699 }
700}
701
702#[async_trait]
703impl RoleStorage for MemoryRbacStorage {
704 async fn create_role(&self, role: &StoredRole) -> StorageResult<()> {
705 self.roles
706 .write()
707 .await
708 .insert(role.id.clone(), role.clone());
709 info!("Created role in memory: {}", role.name);
710 Ok(())
711 }
712
713 async fn update_role(&self, role: &StoredRole) -> StorageResult<()> {
714 self.roles
715 .write()
716 .await
717 .insert(role.id.clone(), role.clone());
718 info!("Updated role in memory: {}", role.name);
719 Ok(())
720 }
721
722 async fn delete_role(&self, role_id: &str) -> StorageResult<()> {
723 self.roles.write().await.remove(role_id);
724 info!("Deleted role from memory: {}", role_id);
725 Ok(())
726 }
727
728 async fn get_role(&self, role_id: &str) -> StorageResult<Option<StoredRole>> {
729 Ok(self.roles.read().await.get(role_id).cloned())
730 }
731
732 async fn list_roles(&self) -> StorageResult<Vec<StoredRole>> {
733 Ok(self.roles.read().await.values().cloned().collect())
734 }
735
736 async fn store_permission(&self, id: &str, permission: &StoredPermission) -> StorageResult<()> {
737 self.permissions
738 .write()
739 .await
740 .insert(id.to_string(), permission.clone());
741 info!(
742 "Created permission in memory: {}:{}",
743 permission.action, permission.resource
744 );
745 Ok(())
746 }
747
748 async fn get_permission(&self, permission_id: &str) -> StorageResult<Option<StoredPermission>> {
749 Ok(self.permissions.read().await.get(permission_id).cloned())
750 }
751
752 async fn assign_role(&self, assignment: &RoleAssignment) -> StorageResult<()> {
753 self.user_roles
754 .write()
755 .await
756 .entry(assignment.user_id.clone())
757 .or_default()
758 .push(assignment.role_id.clone());
759 info!(
760 "Assigned role in memory: {} to {}",
761 assignment.role_id, assignment.user_id
762 );
763 Ok(())
764 }
765
766 async fn revoke_role(&self, user_id: &str, role_id: &str) -> StorageResult<()> {
767 if let Some(roles) = self.user_roles.write().await.get_mut(user_id) {
768 roles.retain(|r| r != role_id);
769 }
770 info!("Revoked role from memory: {} from {}", role_id, user_id);
771 Ok(())
772 }
773
774 async fn get_user_roles(&self, user_id: &str) -> StorageResult<Vec<String>> {
775 Ok(self
776 .user_roles
777 .read()
778 .await
779 .get(user_id)
780 .cloned()
781 .unwrap_or_default())
782 }
783
784 async fn get_role_permissions(&self, role_id: &str) -> StorageResult<Vec<String>> {
785 Ok(self
786 .role_permissions
787 .read()
788 .await
789 .get(role_id)
790 .cloned()
791 .unwrap_or_default())
792 }
793
794 async fn log_audit_entry(&self, entry: &AuditEntry) -> StorageResult<()> {
795 self.audit_log.write().await.push(entry.clone());
796 debug!(
797 "Logged audit entry in memory for user {:?}: {}",
798 entry.user_id, entry.action
799 );
800 Ok(())
801 }
802}
803
804#[cfg(test)]
805mod tests {
806 use super::*;
807
808 #[tokio::test]
809 async fn test_memory_storage_basic_operations() {
810 let storage = MemoryRbacStorage::new();
811
812 let role = StoredRole {
813 id: "test_role".to_string(),
814 name: "Test Role".to_string(),
815 description: Some("A test role".to_string()),
816 permissions: Vec::new(),
817 };
818
819 storage.create_role(&role).await.unwrap();
820
821 let retrieved = storage.get_role("test_role").await.unwrap();
822 assert!(retrieved.is_some());
823 assert_eq!(retrieved.unwrap().name, "Test Role");
824
825 let roles = storage.list_roles().await.unwrap();
826 assert_eq!(roles.len(), 1);
827
828 storage.delete_role("test_role").await.unwrap();
829 let retrieved = storage.get_role("test_role").await.unwrap();
830 assert!(retrieved.is_none());
831 }
832
833 #[tokio::test]
834 async fn test_memory_storage_permissions() {
835 let storage = MemoryRbacStorage::new();
836
837 let permission = StoredPermission {
838 action: "read".to_string(),
839 resource: "users".to_string(),
840 instance: None,
841 };
842
843 storage
844 .store_permission("test_perm", &permission)
845 .await
846 .unwrap();
847
848 let retrieved = storage.get_permission("test_perm").await.unwrap();
849 assert!(retrieved.is_some());
850 assert_eq!(retrieved.unwrap().action, "read");
851 }
852
853 #[tokio::test]
854 async fn test_memory_storage_role_assignment() {
855 let storage = MemoryRbacStorage::new();
856
857 let assignment = RoleAssignment {
858 user_id: "user1".to_string(),
859 role_id: "admin".to_string(),
860 assigned_by: Some("system".to_string()),
861 expires_at: None,
862 };
863
864 storage.assign_role(&assignment).await.unwrap();
865 let user_roles = storage.get_user_roles("user1").await.unwrap();
866 assert_eq!(user_roles, vec!["admin"]);
867
868 storage.revoke_role("user1", "admin").await.unwrap();
869 let user_roles = storage.get_user_roles("user1").await.unwrap();
870 assert!(user_roles.is_empty());
871 }
872
873 #[tokio::test]
874 async fn test_stored_role_conversion_roundtrip() {
875 let stored = StoredRole {
876 id: "role1".to_string(),
877 name: "Admin".to_string(),
878 description: Some("Administrator role".to_string()),
879 permissions: vec![StoredPermission {
880 action: "read".to_string(),
881 resource: "users".to_string(),
882 instance: None,
883 }],
884 };
885
886 let rs_role = stored.to_role_system();
887 assert_eq!(rs_role.id(), "role1");
888 assert_eq!(rs_role.name(), "Admin");
889 assert_eq!(rs_role.description(), Some("Administrator role"));
890
891 let back = StoredRole::from_role_system(&rs_role);
892 assert_eq!(back.id, "role1");
893 assert_eq!(back.name, "Admin");
894 assert_eq!(back.permissions.len(), 1);
895 assert_eq!(back.permissions[0].action, "read");
896 }
897
898 #[tokio::test]
899 async fn test_audit_logging() {
900 let storage = MemoryRbacStorage::new();
901
902 let entry = AuditEntry {
903 user_id: Some("user1".to_string()),
904 action: "login".to_string(),
905 resource: Some("auth".to_string()),
906 result: "success".to_string(),
907 context: HashMap::from([("ip".to_string(), "127.0.0.1".to_string())]),
908 };
909
910 storage.log_audit_entry(&entry).await.unwrap();
911 let log = storage.audit_log.read().await;
912 assert_eq!(log.len(), 1);
913 assert_eq!(log[0].action, "login");
914 }
915}