feat: add map transaction operations

Co-authored-by: MasterMarcoHD <MasterMarcoHD@users.noreply.github.com>

Author: mcquenji

lib/src/transactions/domain/models/list_add_element_tx_operation.dart

@@ -13,7 +13,7 @@ class ListAddElementTxOperation<Element, TResult>
     required this.element,
     required this.createElement,
     required this.apply,
-    this.shouldRollbackOnError = TxOperation.alwaysRollback,
+    super.shouldRollbackOnError = TxOperation.alwaysRollback,
   }) : super(touchedKeys: const <String>{});
 
   @override
@@ -28,10 +28,6 @@ class ListAddElementTxOperation<Element, TResult>
   /// Applies commit result to the optimistic element and returns the confirmed element.
   final Element Function(Element optimisticElement, TResult createResult) apply;
 
-  /// {@macro shouldRollbackOnError}
-  final bool Function(Object error, StackTrace? stackTrace)
-  shouldRollbackOnError;
-
   @override
   List<Element>? applyConfirmed(List<Element> confirmed, TResult result) {
     final appliedElement = apply(element, result);
@@ -47,6 +43,5 @@ class ListAddElementTxOperation<Element, TResult>
   }
 
   @override
-  bool shouldRollback(Object error, StackTrace? stackTrace) =>
-      shouldRollbackOnError(error, stackTrace);
+  String get logTag => 'ListAddElementTxOperation';
 }

lib/src/transactions/domain/models/list_remove_element_tx_operation.dart

@@ -15,7 +15,7 @@ class ListRemoveElementTxOperation<Element, TResult>
     required this.element,
     required this.removeElement,
     required this.apply,
-    this.shouldRollbackOnError = TxOperation.alwaysRollback,
+    super.shouldRollbackOnError = TxOperation.alwaysRollback,
   }) : super(touchedKeys: const <String>{});
 
   @override
@@ -30,10 +30,6 @@ class ListRemoveElementTxOperation<Element, TResult>
   /// Applies commit result to the optimistic element and returns the confirmed element.
   final Element Function(Element optimisticElement, TResult createResult) apply;
 
-  /// {@macro shouldRollbackOnError}
-  final bool Function(Object error, StackTrace? stackTrace)
-  shouldRollbackOnError;
-
   @override
   List<Element>? applyConfirmed(List<Element> confirmed, TResult result) {
     final appliedElement = apply(element, result);
@@ -55,6 +51,5 @@ class ListRemoveElementTxOperation<Element, TResult>
   }
 
   @override
-  bool shouldRollback(Object error, StackTrace? stackTrace) =>
-      shouldRollbackOnError(error, stackTrace);
+  String get logTag => 'ListRemoveElementTxOperation';
 }

lib/src/transactions/domain/models/list_update_element_tx_operation.dart

@@ -17,7 +17,7 @@ class ListUpdateElementTxOperation<Element, TResult>
     required this.apply,
     required this.optimisticUpdate,
     required this.updateElement,
-    this.shouldRollbackOnError = TxOperation.alwaysRollback,
+    super.shouldRollbackOnError = TxOperation.alwaysRollback,
   }) : super(touchedKeys: touchedElementKeys);
 
   @override
@@ -36,10 +36,6 @@ class ListUpdateElementTxOperation<Element, TResult>
   /// Updates the element on the remote and returns the commit result.
   final Future<TResult> Function(Element element) updateElement;
 
-  /// {@macro shouldRollbackOnError}
-  final bool Function(Object error, StackTrace? stackTrace)
-  shouldRollbackOnError;
-
   /// Applies commit result to the optimistic element and returns the confirmed element.
   final Element Function(Element optimisticElement, TResult result) apply;
 
@@ -73,6 +69,5 @@ class ListUpdateElementTxOperation<Element, TResult>
   }
 
   @override
-  bool shouldRollback(Object error, StackTrace? stackTrace) =>
-      shouldRollbackOnError(error, stackTrace);
+  String get logTag => 'ListUpdateElementTxOperation';
 }

lib/src/transactions/domain/models/map_change_key_tx_operation.dart

@@ -0,0 +1,105 @@
+import 'package:grumpy/grumpy.dart';
+
+/// {@template map_change_key_tx_operation}
+/// A [TxOperation] for changing the key of an entry in a map.
+///
+/// To update the value of an entry without changing the key, use [MapUpdateEntryTxOperation] instead.
+/// {@endtemplate}
+class MapChangeKeyTxOperation<Key, Value, TResult>
+    extends TxOperation<Map<Key, Value>, TResult> {
+  /// {@macro map_change_key_tx_operation}
+  MapChangeKeyTxOperation({
+    required super.name,
+    required super.id,
+    required super.baseVersion,
+    required this.oldKey,
+    required this.newKey,
+    required this.changeKey,
+    required this.apply,
+    required this.conflictResolution,
+    super.shouldRollbackOnError = TxOperation.alwaysRollback,
+  }) : super(touchedKeys: {oldKey.toString(), newKey.toString()});
+
+  /// The conflict resolution strategy to use when the [newKey] already exists in the confirmed state.
+  final MapChangeKeyConflictResolution conflictResolution;
+
+  /// The old key of the entry to be updated.
+  final Key oldKey;
+
+  /// The new key of the entry to be updated.
+  final Key newKey;
+
+  /// Changes the key of the entry on the remote and returns the commit result.
+  final Future<TResult> Function(Key oldKey, Key newKey, Value value) changeKey;
+
+  /// Applies commit result to the optimistic entry and returns the confirmed entry.
+  final Key Function(
+    Key oldKey,
+    Key newKey,
+    Value value,
+    TResult confirmedEntry,
+  )
+  apply;
+
+  @override
+  Map<Key, Value>? applyConfirmed(Map<Key, Value> confirmed, TResult result) {
+    if (!confirmed.containsKey(oldKey)) {
+      // Old key not found, cannot apply key change
+      return null;
+    }
+
+    if (confirmed.containsKey(newKey)) {
+      // New key already exists, resolve conflict based on the specified strategy
+      switch (conflictResolution) {
+        case MapChangeKeyConflictResolution.rollback:
+          // Rollback the operation by returning null
+          return null;
+        case MapChangeKeyConflictResolution.overwrite:
+          // Overwrite the existing entry with the new key
+          break;
+      }
+    }
+
+    final value = confirmed[oldKey] as Value;
+    final appliedNewKey = apply(oldKey, newKey, value, result);
+    final copy = Map<Key, Value>.from(confirmed);
+    copy.remove(oldKey);
+    copy[appliedNewKey] = value;
+    return copy;
+  }
+
+  @override
+  Future<TResult> commit(Map<Key, Value> current) {
+    if (!current.containsKey(oldKey)) {
+      // Old key not found, cannot commit key change
+      throw StateError('Old key not found: $oldKey');
+    }
+    final value = current[oldKey] as Value;
+    return changeKey(oldKey, newKey, value);
+  }
+
+  @override
+  Map<Key, Value> optimisticApply(Map<Key, Value> current) {
+    if (!current.containsKey(oldKey)) {
+      // Old key not found, cannot apply key change
+      return current;
+    }
+    final value = current[oldKey] as Value;
+    final copy = Map<Key, Value>.from(current);
+    copy.remove(oldKey);
+    copy[newKey] = value;
+    return copy;
+  }
+
+  @override
+  String get logTag => 'MapChangeKeyTxOperation';
+}
+
+/// Conflict resolution strategies for [MapChangeKeyTxOperation].
+enum MapChangeKeyConflictResolution {
+  /// The operation will be rolled back if the new key already exists in the confirmed state.
+  rollback,
+
+  /// The operation will overwrite the existing entry with the new key if it already exists in the confirmed state.
+  overwrite,
+}

lib/src/transactions/domain/models/map_put_entry_tx_operation.dart

@@ -0,0 +1,57 @@
+import 'package:grumpy/grumpy.dart';
+
+/// {@template map_put_entry_tx_operation}
+/// A [TxOperation] for putting an entry in a map.
+/// {@endtemplate}
+class MapPutEntryTxOperation<Key, Value, TResult>
+    extends TxOperation<Map<Key, Value>, TResult> {
+  /// {@macro map_put_entry_tx_operation}
+  MapPutEntryTxOperation({
+    required super.name,
+    required super.id,
+    required super.baseVersion,
+    required this.key,
+    required this.optimisticValue,
+    super.shouldRollbackOnError = TxOperation.alwaysRollback,
+    required this.putEntry,
+    required this.apply,
+  }) : super(touchedKeys: {key.toString()});
+
+  /// The key of the entry to be put in the map.
+  final Key key;
+
+  /// Creates the entry on the remote and returns the commit result.
+  final Future<TResult> Function() putEntry;
+
+  /// The optimistic value to be put in the map.
+  final Value optimisticValue;
+
+  /// Applies commit result to the optimistic entry and returns the confirmed map.
+  final MapEntry<Key, Value> Function(
+    Key key,
+    Value optimisticValue,
+    TResult putResult,
+  )
+  apply;
+
+  @override
+  Map<Key, Value>? applyConfirmed(Map<Key, Value> confirmed, TResult result) {
+    final copy = Map<Key, Value>.from(confirmed);
+    final appliedEntry = apply(key, optimisticValue, result);
+    copy[appliedEntry.key] = appliedEntry.value;
+    return copy;
+  }
+
+  @override
+  Map<Key, Value> optimisticApply(Map<Key, Value> current) {
+    final copy = Map<Key, Value>.from(current);
+    copy[key] = optimisticValue;
+    return copy;
+  }
+
+  @override
+  Future<TResult> commit(_) => putEntry();
+
+  @override
+  String get logTag => 'MapPutEntryTxOperation';
+}

lib/src/transactions/domain/models/map_remove_entry_tx_operation.dart

@@ -0,0 +1,48 @@
+import 'package:grumpy/grumpy.dart';
+
+/// {@template map_remove_entry_tx_operation}
+/// A [TxOperation] that removes an entry from a [Map].
+/// {@endtemplate}
+class MapRemoveEntryTxOperation<Key, Value, TResult>
+    extends TxOperation<Map<Key, Value>, TResult> {
+  /// {@macro map_remove_entry_tx_operation}
+  MapRemoveEntryTxOperation({
+    required super.name,
+    required super.id,
+    required super.baseVersion,
+    required this.key,
+    required this.removeEntry,
+    required this.apply,
+    super.shouldRollbackOnError = TxOperation.alwaysRollback,
+  }) : super(touchedKeys: {key.toString()});
+
+  /// The key of the entry to remove.
+  final Key key;
+
+  /// Removes the entry and returns the commit result.
+  final Future<TResult> Function() removeEntry;
+
+  /// Applies commit result to the optimistic entry and returns the confirmed map.
+  final MapEntry<Key, Value> Function(Key key, TResult confirmedEntry) apply;
+
+  @override
+  Map<Key, Value>? applyConfirmed(Map<Key, Value> confirmed, TResult result) {
+    final copy = Map<Key, Value>.from(confirmed);
+    final optimisticEntry = apply(key, result);
+    copy.remove(optimisticEntry.key);
+    return copy;
+  }
+
+  @override
+  Future<TResult> commit(_) => removeEntry();
+
+  @override
+  Map<Key, Value> optimisticApply(Map<Key, Value> current) {
+    final copy = Map<Key, Value>.from(current);
+    copy.removeWhere((k, v) => k == key);
+    return copy;
+  }
+
+  @override
+  String get logTag => 'MapRemoveEntryTxOperation';
+}

lib/src/transactions/domain/models/map_update_entry_tx_operation.dart

@@ -0,0 +1,74 @@
+import 'package:grumpy/grumpy.dart';
+
+/// {@template map_update_entry_tx_operation}
+/// A [TxOperation] for updating an entry in a map.
+///
+/// Note: To change the key of an entry, use [MapChangeKeyTxOperation] instead.
+/// {@endtemplate}
+class MapUpdateEntryTxOperation<Key, Value, TResult>
+    extends TxOperation<Map<Key, Value>, TResult> {
+  /// {@macro map_update_entry_tx_operation}
+  const MapUpdateEntryTxOperation({
+    required super.name,
+    required super.id,
+    required super.baseVersion,
+    required this.key,
+    required this.touchedValueKeys,
+    required this.apply,
+    required this.updateEntry,
+    required this.optimisticUpdate,
+  }) : super(touchedKeys: const <String>{});
+
+  @override
+  Set<String> get touchedKeys => touchedValueKeys.map((k) => '$key.$k').toSet();
+
+  /// The key of the entry to be updated.
+  final Key key;
+
+  /// The keys of the value that are touched by this operation. This is used to determine if this operation conflicts with other operations that touch the same keys.
+  final Set<String> touchedValueKeys;
+
+  /// Applies commit result to the optimistic entry and returns the confirmed map entry.
+  final MapEntry<Key, Value> Function(
+    MapEntry<Key, Value> optimisticEntry,
+    TResult confirmedEntry,
+  )
+  apply;
+
+  /// Updates the entry on the remote and returns the commit result.
+  final Future<TResult> Function(MapEntry<Key, Value> entry) updateEntry;
+
+  /// Returns the optimistically updated value based on the current entry.
+  final Value Function(MapEntry<Key, Value> current) optimisticUpdate;
+
+  @override
+  Map<Key, Value>? applyConfirmed(Map<Key, Value> confirmed, TResult result) {
+    if (!confirmed.containsKey(key)) {
+      // Key not found, cannot apply update
+      return null;
+    }
+    final optimisticEntry = MapEntry(key, confirmed[key] as Value);
+    final appliedEntry = apply(optimisticEntry, result);
+    final copy = Map<Key, Value>.from(confirmed);
+    copy[appliedEntry.key] = appliedEntry.value;
+    return copy;
+  }
+
+  @override
+  Future<TResult> commit(Map<Key, Value> current) {
+    final currentEntry = MapEntry(key, current[key] as Value);
+    return updateEntry(currentEntry);
+  }
+
+  @override
+  Map<Key, Value> optimisticApply(Map<Key, Value> current) {
+    final currentEntry = MapEntry(key, current[key] as Value);
+    final optimisticValue = optimisticUpdate(currentEntry);
+    final copy = Map<Key, Value>.from(current);
+    copy[key] = optimisticValue;
+    return copy;
+  }
+
+  @override
+  String get logTag => 'MapUpdateEntryTxOperation';
+}

lib/src/transactions/domain/models/models.dart

@@ -7,3 +7,7 @@ export 'simple_tx_operation.dart';
 export 'list_add_element_tx_operation.dart';
 export 'list_remove_element_tx_operation.dart';
 export 'list_update_element_tx_operation.dart';
+export 'map_put_entry_tx_operation.dart';
+export 'map_remove_entry_tx_operation.dart';
+export 'map_update_entry_tx_operation.dart';
+export 'map_change_key_tx_operation.dart';