Skip to main content

auth_framework/authorization_enhanced/
storage.rs

1//! Storage adapters for role-system integration
2//!
3//! This module provides storage adapters that integrate role-system with
4//! AuthFramework's existing storage infrastructure. It defines its own
5//! serializable types (`StoredRole`, `StoredPermission`) for persistence,
6//! with conversions to/from the `role_system` crate's types.
7
8use 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// ── Storage-layer error types ────────────────────────────────────────────────
16
17/// Error type for storage operations
18#[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
28/// Result alias for storage operations
29pub type StorageResult<T> = Result<T, StorageError>;
30
31// ── Serializable storage types (decoupled from role_system's private fields) ─
32
33/// A serializable role representation for persistence
34#[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/// A serializable permission representation for persistence
43#[derive(Debug, Clone, Serialize, Deserialize)]
44pub struct StoredPermission {
45    pub action: String,
46    pub resource: String,
47    pub instance: Option<String>,
48}
49
50/// A role-to-user assignment record
51#[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/// An audit log entry for authorization events
60#[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
69// ── Conversions between storage types and role_system types ──────────────────
70
71impl StoredRole {
72    /// Convert to a `role_system::Role` (for use with the role-system engine)
73    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    /// Create from a `role_system::Role`
85    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    /// Convert to a `role_system::Permission`
102    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    /// Create from a `role_system::Permission`
111    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 storage trait ─────────────────────────────────────────────────────
121
122/// Async storage trait for persisting RBAC data (roles, permissions, assignments, audit)
123#[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
142// ── Database abstractions ───────────────────────────────────────────────────
143
144/// Database-backed storage adapter for role-system
145pub 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/// Database connection trait (abstraction over actual database)
153#[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
172/// Database value trait for query parameters
173pub 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/// Database query result
240#[derive(Debug)]
241pub struct QueryResult {
242    pub rows_affected: u64,
243}
244
245/// Database row
246#[derive(Debug)]
247pub struct Row {
248    pub columns: HashMap<String, DatabaseColumnValue>,
249}
250
251/// Database column value
252#[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            // A column can hold anything, including a credential.
264            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/// Database error
276#[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    /// Create new database storage adapter
288    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, // 5 minutes
294        }
295    }
296
297    /// Set cache TTL
298    pub fn with_cache_ttl(mut self, ttl_seconds: u64) -> Self {
299        self.cache_ttl = ttl_seconds;
300        self
301    }
302
303    /// Initialize database schema
304    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    /// Clear caches
381    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(), // loaded via role_permissions join
396        })
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
664// ── In-memory storage (for testing and development) ─────────────────────────
665
666/// In-memory storage adapter for testing and development
667pub 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    /// Clear all data (useful for testing)
693    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}