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