feat(policy): enhance management by add deep copy functionality and integrating collection package

Author: dgarciasquare1

lib/src/core/memory_policy_storage.dart

@@ -11,6 +11,7 @@ import 'package:flutter_policy_engine/src/core/interfaces/i_policy_storage.dart'
 ///
 /// **Note:** All data stored in this implementation will be lost when the
 /// application is terminated or the object is garbage collected.
+// ignore: must_be_immutable
 class MemoryPolicyStorage implements IPolicyStorage {
   /// Internal storage for policies using a Map with String keys and dynamic values.
   ///
@@ -34,7 +35,7 @@ class MemoryPolicyStorage implements IPolicyStorage {
   /// ```
   @override
   Future<Map<String, dynamic>> loadPolicies() async {
-    return Map.from(_policies);
+    return _deepCopy(_policies);
   }
 
   /// Saves the provided policies to memory storage.
@@ -54,7 +55,7 @@ class MemoryPolicyStorage implements IPolicyStorage {
   /// ```
   @override
   Future<void> savePolicies(Map<String, dynamic> policies) async {
-    _policies = Map.from(policies);
+    _policies = _deepCopy(policies);
   }
 
   /// Removes all stored policies from memory.
@@ -72,4 +73,24 @@ class MemoryPolicyStorage implements IPolicyStorage {
   Future<void> clearPolicies() async {
     _policies.clear();
   }
+
+  /// Creates a deep copy of the policies map.
+  Map<String, dynamic> _deepCopy(Map<String, dynamic> source) {
+    final result = <String, dynamic>{};
+    for (final entry in source.entries) {
+      result[entry.key] = _deepCopyValue(entry.value);
+    }
+    return result;
+  }
+
+  /// Creates a deep copy of a single value.
+  dynamic _deepCopyValue(dynamic value) {
+    if (value is Map) {
+      return _deepCopy(Map<String, dynamic>.from(value));
+    } else if (value is List) {
+      return value.map((item) => _deepCopyValue(item)).toList();
+    } else {
+      return value;
+    }
+  }
 }

lib/src/core/policy_manager.dart

@@ -79,22 +79,68 @@ class PolicyManager extends ChangeNotifier {
         operation: 'policy_manager_initialize',
       );
 
-      final policyMap = jsonPolicies.map(
-        (key, value) => MapEntry(
-          key,
-          Policy(
+      // Create a map of valid policies, skipping invalid ones
+      final validPolicies = <String, Map<String, dynamic>>{};
+
+      for (final entry in jsonPolicies.entries) {
+        final key = entry.key;
+        final value = entry.value;
+
+        try {
+          if (value == null) {
+            LogHandler.warning(
+              'Skipping null policy value',
+              context: {'role': key},
+              operation: 'policy_validation_skip',
+            );
+            continue;
+          }
+
+          if (value is! List) {
+            LogHandler.warning(
+              'Skipping invalid policy value type',
+              context: {
+                'role': key,
+                'expected_type': 'List',
+                'actual_type': value.runtimeType.toString(),
+              },
+              operation: 'policy_validation_skip',
+            );
+            continue;
+          }
+
+          if (value.any((item) => item is! String)) {
+            LogHandler.warning(
+              'Skipping policy with non-string content items',
+              context: {'role': key},
+              operation: 'policy_validation_skip',
+            );
+            continue;
+          }
+
+          // Create the policy and add to valid policies
+          final policy = Policy(
             roleName: key,
-            allowedContent: value as List<String>,
-          ).toJson(),
-        ),
-      );
+            allowedContent: value.cast<String>(),
+          );
+          validPolicies[key] = policy.toJson();
+        } catch (e, stackTrace) {
+          LogHandler.error(
+            'Failed to process policy',
+            error: e,
+            stackTrace: stackTrace,
+            context: {'role': key},
+            operation: 'policy_processing_error',
+          );
+          // Continue with other policies
+        }
+      }
 
       _policies = JsonHandler.parseMap(
-        policyMap,
+        validPolicies,
         (json) => Policy.fromJson(json),
         context: 'policy_manager',
-        allowPartialSuccess:
-            true, // Allow partial success for graceful degradation
+        allowPartialSuccess: true,
       );
 
       // Only create evaluator if we have at least some policies

lib/src/models/policy.dart

@@ -1,4 +1,5 @@
-import 'package:meta/meta.dart';
+import 'package:flutter/foundation.dart';
+import 'package:collection/collection.dart';
 
 /// Represents a policy that defines content access permissions for a specific role.
 ///
@@ -91,19 +92,29 @@ class Policy {
   /// the same [allowedContent] (regardless of order). The [metadata] is not
   /// considered in the equality comparison.
   @override
-  bool operator ==(Object other) =>
-      identical(this, other) ||
-      other is Policy &&
-          roleName == other.roleName &&
-          allowedContent.length == other.allowedContent.length &&
-          allowedContent
-              .every((content) => other.allowedContent.contains(content));
+  bool operator ==(Object other) {
+    if (identical(this, other)) return true;
+    if (other is! Policy) return false;
+
+    if (roleName != other.roleName) return false;
+    if (allowedContent.length != other.allowedContent.length) return false;
+
+    // Sort both lists to ensure order-independent comparison (same as hashCode)
+    final sortedThis = List<String>.from(allowedContent)..sort();
+    final sortedOther = List<String>.from(other.allowedContent)..sort();
+
+    return listEquals(sortedThis, sortedOther);
+  }
 
   /// Returns the hash code for this policy.
   ///
   /// The hash code is based on the [roleName] and [allowedContent] fields.
+  /// The allowedContent is sorted to ensure consistent hash codes regardless of order.
   @override
-  int get hashCode => roleName.hashCode ^ allowedContent.hashCode;
+  int get hashCode {
+    final sortedContent = List<String>.from(allowedContent)..sort();
+    return Object.hash(roleName, const ListEquality().hash(sortedContent));
+  }
 
   /// Returns a string representation of this policy.
   ///
@@ -130,11 +141,28 @@ class Policy {
   /// };
   /// final policy = Policy.fromJson(json);
   /// ```
-  factory Policy.fromJson(Map<String, dynamic> json) => Policy(
-        roleName: json['roleName'] as String,
-        allowedContent: json['allowedContent'] as List<String>,
-        metadata: json['metadata'] as Map<String, dynamic>,
-      );
+  factory Policy.fromJson(Map<String, dynamic> json) {
+    final roleName = json['roleName'];
+    final allowedContent = json['allowedContent'];
+    final metadata = json['metadata'];
+
+    if (roleName == null || roleName is! String) {
+      throw ArgumentError('roleName must be a non-null string');
+    }
+    if (allowedContent == null || allowedContent is! List) {
+      throw ArgumentError('allowedContent must be a non-null list');
+    }
+    if (allowedContent.any((item) => item is! String)) {
+      throw ArgumentError('All allowedContent items must be strings');
+    }
+
+    return Policy(
+      roleName: roleName,
+      allowedContent: allowedContent.cast<String>(),
+      metadata:
+          metadata is Map<String, dynamic> ? metadata : <String, dynamic>{},
+    );
+  }
 
   /// Converts this policy to a JSON map.
   ///

pubspec.yaml

@@ -8,6 +8,7 @@ environment:
   flutter: ">=1.17.0"
 
 dependencies:
+  collection: ^1.19.1
   flutter:
     sdk: flutter
   meta: ^1.12.0