Skip to main content

auth_framework/migration/
converters.rs

1//! Migration converters for transforming legacy data structures
2//!
3//! This module provides converters to transform legacy authorization
4//! data into role-system v1.0 compatible formats.
5
6use super::{LegacyPermission, LegacyRole, LegacyUserAssignment, MigrationError};
7use serde::{Deserialize, Serialize};
8use std::collections::HashMap;
9
10/// Converted role data compatible with role-system v1.0
11#[derive(Debug, Clone, Serialize, Deserialize)]
12pub struct ConvertedRole {
13    pub id: String,
14    pub name: String,
15    pub description: Option<String>,
16    pub permissions: Vec<String>,
17    pub parent_role_id: Option<String>,
18    pub metadata: HashMap<String, String>,
19    pub created_at: chrono::DateTime<chrono::Utc>,
20    pub updated_at: chrono::DateTime<chrono::Utc>,
21}
22
23/// Converted permission data
24#[derive(Debug, Clone, Serialize, Deserialize)]
25pub struct ConvertedPermission {
26    pub id: String,
27    pub action: String,
28    pub resource: String,
29    pub conditions: HashMap<String, String>,
30    pub created_at: chrono::DateTime<chrono::Utc>,
31}
32
33/// Converted user assignment data
34#[derive(Debug, Clone, Serialize, Deserialize)]
35pub struct ConvertedUserAssignment {
36    pub user_id: String,
37    pub role_id: String,
38    pub assigned_at: chrono::DateTime<chrono::Utc>,
39    pub assigned_by: Option<String>,
40    pub expires_at: Option<chrono::DateTime<chrono::Utc>>,
41    pub metadata: HashMap<String, String>,
42}
43
44/// Role converter for transforming legacy roles
45pub struct RoleConverter {
46    id_prefix: String,
47    preserve_hierarchy: bool,
48    merge_duplicate_permissions: bool,
49}
50
51impl Default for RoleConverter {
52    fn default() -> Self {
53        Self {
54            id_prefix: "migrated_".to_string(),
55            preserve_hierarchy: true,
56            merge_duplicate_permissions: true,
57        }
58    }
59}
60
61impl RoleConverter {
62    /// Create new role converter with custom settings.
63    ///
64    /// For a more readable alternative, prefer the builder API:
65    ///
66    /// ```rust,ignore
67    /// RoleConverter::default()
68    ///     .with_id_prefix("imported_")
69    ///     .without_hierarchy()
70    /// ```
71    pub fn new(
72        id_prefix: String,
73        preserve_hierarchy: bool,
74        merge_duplicate_permissions: bool,
75    ) -> Self {
76        Self {
77            id_prefix,
78            preserve_hierarchy,
79            merge_duplicate_permissions,
80        }
81    }
82
83    /// Set the ID prefix for converted roles (default: `"migrated_"`).
84    pub fn with_id_prefix(mut self, prefix: impl Into<String>) -> Self {
85        self.id_prefix = prefix.into();
86        self
87    }
88
89    /// Preserve the role hierarchy from the legacy system (default: `true`).
90    pub fn with_hierarchy(mut self) -> Self {
91        self.preserve_hierarchy = true;
92        self
93    }
94
95    /// Discard the role hierarchy from the legacy system.
96    pub fn without_hierarchy(mut self) -> Self {
97        self.preserve_hierarchy = false;
98        self
99    }
100
101    /// Merge duplicate permissions during conversion (default: `true`).
102    pub fn with_deduplication(mut self) -> Self {
103        self.merge_duplicate_permissions = true;
104        self
105    }
106
107    /// Keep duplicate permissions as-is during conversion.
108    pub fn without_deduplication(mut self) -> Self {
109        self.merge_duplicate_permissions = false;
110        self
111    }
112
113    /// Convert legacy role to role-system v1.0 format
114    pub fn convert_role(&self, legacy_role: &LegacyRole) -> Result<ConvertedRole, MigrationError> {
115        let now = chrono::Utc::now();
116
117        let mut permissions = legacy_role.permissions.clone();
118
119        // Remove duplicates if enabled
120        if self.merge_duplicate_permissions {
121            permissions.sort();
122            permissions.dedup();
123        }
124
125        // Handle parent role (role-system v1.0 supports single parent)
126        let parent_role_id = if self.preserve_hierarchy && !legacy_role.parent_roles.is_empty() {
127            // Take the first parent role if multiple exist
128            Some(format!("{}{}", self.id_prefix, legacy_role.parent_roles[0]))
129        } else {
130            None
131        };
132
133        // Convert metadata
134        let mut metadata = legacy_role.metadata.clone();
135
136        // Add migration metadata
137        metadata.insert("migration_source".to_string(), "legacy_system".to_string());
138        metadata.insert("original_id".to_string(), legacy_role.id.clone());
139
140        if legacy_role.parent_roles.len() > 1 {
141            metadata.insert(
142                "original_parent_roles".to_string(),
143                legacy_role.parent_roles.join(","),
144            );
145        }
146
147        Ok(ConvertedRole {
148            id: format!("{}{}", self.id_prefix, legacy_role.id),
149            name: legacy_role.name.clone(),
150            description: legacy_role.description.clone(),
151            permissions,
152            parent_role_id,
153            metadata,
154            created_at: now,
155            updated_at: now,
156        })
157    }
158
159    /// Convert multiple legacy roles with dependency resolution
160    pub fn convert_roles(
161        &self,
162        legacy_roles: &[LegacyRole],
163    ) -> Result<Vec<ConvertedRole>, MigrationError> {
164        let mut converted_roles = Vec::new();
165        let mut role_map: HashMap<String, &LegacyRole> = HashMap::new();
166
167        // Build role map for dependency lookup
168        for role in legacy_roles {
169            role_map.insert(role.id.clone(), role);
170        }
171
172        // Convert roles in dependency order (parents first)
173        let ordered_roles = self.order_roles_by_dependencies(legacy_roles)?;
174
175        for role in ordered_roles {
176            let converted = self.convert_role(role)?;
177            converted_roles.push(converted);
178        }
179
180        Ok(converted_roles)
181    }
182
183    /// Order roles by dependencies (parents before children)
184    fn order_roles_by_dependencies<'a>(
185        &self,
186        roles: &'a [LegacyRole],
187    ) -> Result<Vec<&'a LegacyRole>, MigrationError> {
188        let mut ordered = Vec::new();
189        let mut visited = std::collections::HashSet::new();
190        let mut visiting = std::collections::HashSet::new();
191        let role_map: HashMap<String, &LegacyRole> =
192            roles.iter().map(|role| (role.id.clone(), role)).collect();
193
194        for role in roles {
195            if !visited.contains(&role.id) {
196                self.visit_role_dependencies(
197                    role,
198                    &role_map,
199                    &mut ordered,
200                    &mut visited,
201                    &mut visiting,
202                )?;
203            }
204        }
205
206        Ok(ordered)
207    }
208
209    /// Visit role dependencies recursively
210    #[allow(clippy::only_used_in_recursion)]
211    fn visit_role_dependencies<'a>(
212        &self,
213        role: &'a LegacyRole,
214        role_map: &HashMap<String, &'a LegacyRole>,
215        ordered: &mut Vec<&'a LegacyRole>,
216        visited: &mut std::collections::HashSet<String>,
217        visiting: &mut std::collections::HashSet<String>,
218    ) -> Result<(), MigrationError> {
219        if visiting.contains(&role.id) {
220            return Err(MigrationError::AnalysisError(format!(
221                "Circular dependency detected involving role '{}'",
222                role.id
223            )));
224        }
225
226        if visited.contains(&role.id) {
227            return Ok(());
228        }
229
230        visiting.insert(role.id.clone());
231
232        // Visit all parent roles first
233        for parent_id in &role.parent_roles {
234            if let Some(parent_role) = role_map.get(parent_id) {
235                self.visit_role_dependencies(parent_role, role_map, ordered, visited, visiting)?;
236            }
237        }
238
239        visiting.remove(&role.id);
240        visited.insert(role.id.clone());
241        ordered.push(role);
242
243        Ok(())
244    }
245}
246
247/// Permission converter for transforming legacy permissions
248pub struct PermissionConverter {
249    id_prefix: String,
250    normalize_actions: bool,
251    normalize_resources: bool,
252}
253
254impl Default for PermissionConverter {
255    fn default() -> Self {
256        Self {
257            id_prefix: "migrated_".to_string(),
258            normalize_actions: true,
259            normalize_resources: true,
260        }
261    }
262}
263
264impl PermissionConverter {
265    /// Create new permission converter
266    pub fn new(id_prefix: String, normalize_actions: bool, normalize_resources: bool) -> Self {
267        Self {
268            id_prefix,
269            normalize_actions,
270            normalize_resources,
271        }
272    }
273
274    /// Convert legacy permission to role-system v1.0 format
275    pub fn convert_permission(
276        &self,
277        legacy_permission: &LegacyPermission,
278    ) -> Result<ConvertedPermission, MigrationError> {
279        let now = chrono::Utc::now();
280
281        let action = if self.normalize_actions {
282            self.normalize_action(&legacy_permission.action)
283        } else {
284            legacy_permission.action.clone()
285        };
286
287        let resource = if self.normalize_resources {
288            self.normalize_resource(&legacy_permission.resource)
289        } else {
290            legacy_permission.resource.clone()
291        };
292
293        let mut conditions = legacy_permission.conditions.clone();
294
295        // Add migration metadata to conditions
296        conditions.insert("migration_source".to_string(), "legacy_system".to_string());
297        conditions.insert("original_id".to_string(), legacy_permission.id.clone());
298
299        Ok(ConvertedPermission {
300            id: format!("{}{}", self.id_prefix, legacy_permission.id),
301            action,
302            resource,
303            conditions,
304            created_at: now,
305        })
306    }
307
308    /// Convert multiple permissions
309    pub fn convert_permissions(
310        &self,
311        legacy_permissions: &[LegacyPermission],
312    ) -> Result<Vec<ConvertedPermission>, MigrationError> {
313        legacy_permissions
314            .iter()
315            .map(|perm| self.convert_permission(perm))
316            .collect()
317    }
318
319    /// Normalize action names to standard format
320    fn normalize_action(&self, action: &str) -> String {
321        match action.to_lowercase().as_str() {
322            "read" | "view" | "get" | "list" => "read".to_string(),
323            "write" | "create" | "post" | "add" => "create".to_string(),
324            "update" | "put" | "patch" | "modify" | "edit" => "update".to_string(),
325            "delete" | "remove" | "destroy" => "delete".to_string(),
326            "execute" | "run" | "invoke" => "execute".to_string(),
327            "admin" | "manage" | "administrate" => "manage".to_string(),
328            _ => action.to_string(),
329        }
330    }
331
332    /// Normalize resource names to standard format
333    fn normalize_resource(&self, resource: &str) -> String {
334        // Convert to lowercase and replace common separators
335        resource
336            .to_lowercase()
337            .replace("-", "_")
338            .replace(" ", "_")
339            .replace("/", "_")
340    }
341}
342
343/// User assignment converter
344pub struct UserAssignmentConverter {
345    default_assigned_by: Option<String>,
346    preserve_expiration: bool,
347}
348
349impl Default for UserAssignmentConverter {
350    fn default() -> Self {
351        Self {
352            default_assigned_by: Some("migration_system".to_string()),
353            preserve_expiration: true,
354        }
355    }
356}
357
358impl UserAssignmentConverter {
359    /// Create new user assignment converter
360    pub fn new(default_assigned_by: Option<String>, preserve_expiration: bool) -> Self {
361        Self {
362            default_assigned_by,
363            preserve_expiration,
364        }
365    }
366
367    /// Convert legacy user assignment
368    pub fn convert_user_assignment(
369        &self,
370        legacy_assignment: &LegacyUserAssignment,
371        role_mappings: &HashMap<String, String>,
372    ) -> Result<Option<ConvertedUserAssignment>, MigrationError> {
373        let now = chrono::Utc::now();
374
375        // Get the mapped role ID
376        let role_id = if let Some(legacy_role_id) = &legacy_assignment.role_id {
377            if let Some(new_role_id) = role_mappings.get(legacy_role_id) {
378                new_role_id.clone()
379            } else {
380                return Err(MigrationError::AnalysisError(format!(
381                    "No role mapping found for legacy role '{}'",
382                    legacy_role_id
383                )));
384            }
385        } else {
386            // Handle permission-only assignments by creating a temporary role
387            return Ok(None); // Skip for now, could be handled with dynamic role creation
388        };
389
390        let expires_at = if self.preserve_expiration {
391            legacy_assignment.expiration
392        } else {
393            None
394        };
395
396        let mut metadata = HashMap::new();
397
398        // Convert attributes to metadata
399        for (key, value) in &legacy_assignment.attributes {
400            metadata.insert(key.clone(), value.clone());
401        }
402
403        // Add migration metadata
404        metadata.insert("migration_source".to_string(), "legacy_system".to_string());
405        metadata.insert(
406            "original_permissions".to_string(),
407            legacy_assignment.permissions.join(","),
408        );
409
410        Ok(Some(ConvertedUserAssignment {
411            user_id: legacy_assignment.user_id.clone(),
412            role_id,
413            assigned_at: now,
414            assigned_by: self.default_assigned_by.clone(),
415            expires_at,
416            metadata,
417        }))
418    }
419
420    /// Convert multiple user assignments
421    pub fn convert_user_assignments(
422        &self,
423        legacy_assignments: &[LegacyUserAssignment],
424        role_mappings: &HashMap<String, String>,
425    ) -> Result<Vec<ConvertedUserAssignment>, MigrationError> {
426        let mut converted = Vec::new();
427
428        for assignment in legacy_assignments {
429            if let Some(converted_assignment) =
430                self.convert_user_assignment(assignment, role_mappings)?
431            {
432                converted.push(converted_assignment);
433            }
434        }
435
436        Ok(converted)
437    }
438}
439
440/// Comprehensive converter that handles all data types
441#[derive(Default)]
442pub struct LegacySystemConverter {
443    role_converter: RoleConverter,
444    permission_converter: PermissionConverter,
445    user_assignment_converter: UserAssignmentConverter,
446}
447
448impl LegacySystemConverter {
449    /// Create new system converter with custom components
450    pub fn new(
451        role_converter: RoleConverter,
452        permission_converter: PermissionConverter,
453        user_assignment_converter: UserAssignmentConverter,
454    ) -> Self {
455        Self {
456            role_converter,
457            permission_converter,
458            user_assignment_converter,
459        }
460    }
461
462    /// Convert entire legacy system
463    pub fn convert_system(
464        &self,
465        legacy_roles: &[LegacyRole],
466        legacy_permissions: &[LegacyPermission],
467        legacy_assignments: &[LegacyUserAssignment],
468    ) -> Result<ConvertedSystem, MigrationError> {
469        // Convert roles first (needed for user assignment mapping)
470        let converted_roles = self.role_converter.convert_roles(legacy_roles)?;
471
472        // Build role mapping
473        let role_mappings: HashMap<String, String> = legacy_roles
474            .iter()
475            .zip(&converted_roles)
476            .map(|(legacy, converted)| (legacy.id.clone(), converted.id.clone()))
477            .collect();
478
479        // Convert permissions
480        let converted_permissions = self
481            .permission_converter
482            .convert_permissions(legacy_permissions)?;
483
484        // Convert user assignments
485        let converted_assignments = self
486            .user_assignment_converter
487            .convert_user_assignments(legacy_assignments, &role_mappings)?;
488
489        Ok(ConvertedSystem {
490            roles: converted_roles,
491            permissions: converted_permissions,
492            user_assignments: converted_assignments,
493            role_mappings,
494            conversion_metadata: self.generate_conversion_metadata(
495                legacy_roles,
496                legacy_permissions,
497                legacy_assignments,
498            ),
499        })
500    }
501
502    /// Generate metadata about the conversion process
503    fn generate_conversion_metadata(
504        &self,
505        legacy_roles: &[LegacyRole],
506        legacy_permissions: &[LegacyPermission],
507        legacy_assignments: &[LegacyUserAssignment],
508    ) -> ConversionMetadata {
509        ConversionMetadata {
510            converted_at: chrono::Utc::now(),
511            legacy_role_count: legacy_roles.len(),
512            legacy_permission_count: legacy_permissions.len(),
513            legacy_assignment_count: legacy_assignments.len(),
514            conversion_summary: format!(
515                "Converted {} roles, {} permissions, and {} user assignments",
516                legacy_roles.len(),
517                legacy_permissions.len(),
518                legacy_assignments.len()
519            ),
520        }
521    }
522}
523
524/// Complete converted system
525#[derive(Debug, Clone, Serialize, Deserialize)]
526pub struct ConvertedSystem {
527    pub roles: Vec<ConvertedRole>,
528    pub permissions: Vec<ConvertedPermission>,
529    pub user_assignments: Vec<ConvertedUserAssignment>,
530    pub role_mappings: HashMap<String, String>,
531    pub conversion_metadata: ConversionMetadata,
532}
533
534/// Metadata about the conversion process
535#[derive(Debug, Clone, Serialize, Deserialize)]
536pub struct ConversionMetadata {
537    pub converted_at: chrono::DateTime<chrono::Utc>,
538    pub legacy_role_count: usize,
539    pub legacy_permission_count: usize,
540    pub legacy_assignment_count: usize,
541    pub conversion_summary: String,
542}
543
544#[cfg(test)]
545mod tests {
546    use super::*;
547
548    fn create_test_role() -> LegacyRole {
549        LegacyRole {
550            id: "admin".to_string(),
551            name: "Administrator".to_string(),
552            description: Some("Admin role".to_string()),
553            permissions: vec!["read".to_string(), "write".to_string(), "read".to_string()], // Duplicate
554            parent_roles: vec!["super_admin".to_string()],
555            metadata: {
556                let mut map = HashMap::new();
557                map.insert("priority".to_string(), "high".to_string());
558                map
559            },
560        }
561    }
562
563    #[test]
564    fn test_role_converter() {
565        let converter = RoleConverter::default();
566        let legacy_role = create_test_role();
567
568        let converted = converter.convert_role(&legacy_role).unwrap();
569
570        assert_eq!(converted.id, "migrated_admin");
571        assert_eq!(converted.name, "Administrator");
572        assert_eq!(converted.permissions.len(), 2); // Duplicates removed
573        assert_eq!(
574            converted.parent_role_id,
575            Some("migrated_super_admin".to_string())
576        );
577        assert!(converted.metadata.contains_key("migration_source"));
578    }
579
580    #[test]
581    fn test_permission_converter() {
582        let converter = PermissionConverter::default();
583        let legacy_permission = LegacyPermission {
584            id: "read_data".to_string(),
585            action: "VIEW".to_string(),
586            resource: "User-Data".to_string(),
587            conditions: HashMap::new(),
588            metadata: HashMap::new(),
589        };
590
591        let converted = converter.convert_permission(&legacy_permission).unwrap();
592
593        assert_eq!(converted.id, "migrated_read_data");
594        assert_eq!(converted.action, "read"); // Normalized
595        assert_eq!(converted.resource, "user_data"); // Normalized
596        assert!(converted.conditions.contains_key("migration_source"));
597    }
598
599    #[test]
600    fn test_user_assignment_converter() {
601        let converter = UserAssignmentConverter::default();
602        let legacy_assignment = LegacyUserAssignment {
603            user_id: "user123".to_string(),
604            role_id: Some("admin".to_string()),
605            permissions: vec!["read".to_string()],
606            attributes: {
607                let mut map = HashMap::new();
608                map.insert("department".to_string(), "IT".to_string());
609                map
610            },
611            expiration: None,
612        };
613
614        let mut role_mappings = HashMap::new();
615        role_mappings.insert("admin".to_string(), "migrated_admin".to_string());
616
617        let converted = converter
618            .convert_user_assignment(&legacy_assignment, &role_mappings)
619            .unwrap()
620            .unwrap();
621
622        assert_eq!(converted.user_id, "user123");
623        assert_eq!(converted.role_id, "migrated_admin");
624        assert!(converted.metadata.contains_key("department"));
625        assert!(converted.metadata.contains_key("migration_source"));
626    }
627
628    #[test]
629    fn test_system_converter() {
630        let converter = LegacySystemConverter::default();
631
632        let legacy_roles = vec![create_test_role()];
633        let legacy_permissions = vec![];
634        let legacy_assignments = vec![];
635
636        let converted_system = converter
637            .convert_system(&legacy_roles, &legacy_permissions, &legacy_assignments)
638            .unwrap();
639
640        assert_eq!(converted_system.roles.len(), 1);
641        assert_eq!(converted_system.permissions.len(), 0);
642        assert_eq!(converted_system.user_assignments.len(), 0);
643        assert_eq!(converted_system.role_mappings.len(), 1);
644    }
645}