Merge branch 'main' into issues/1-missing-data-types

lib/kiota_abstractions.dart

@@ -37,10 +37,13 @@ part 'src/response_handler.dart';
 part 'src/response_handler_option.dart';
 part 'src/serialization/parsable.dart';
 part 'src/serialization/parsable_factory.dart';
+part 'src/serialization/parsable_hook.dart';
 part 'src/serialization/parse_node.dart';
 part 'src/serialization/parse_node_factory.dart';
 part 'src/serialization/parse_node_factory_registry.dart';
+part 'src/serialization/parse_node_proxy_factory.dart';
 part 'src/serialization/serialization_writer.dart';
 part 'src/serialization/serialization_writer_factory.dart';
 part 'src/serialization/serialization_writer_factory_registry.dart';
 part 'src/time_only.dart';
+part 'src/serialization/serialization_writer_proxy_factory.dart';

lib/src/serialization/parsable_hook.dart

@@ -0,0 +1,7 @@
+part of '../../kiota_abstractions.dart';
+
+/// A hook that can be added before or after the parsing of a [Parsable] object.
+///
+/// See [ParseNode] or [ParseNodeProxyFactory] for abilities to add hooks to the
+/// parsing of a [Parsable] object.
+typedef ParsableHook = void Function(Parsable);

lib/src/serialization/parse_node.dart

@@ -55,8 +55,8 @@ abstract class ParseNode {
   Uint8List? getByteArrayValue();
 
   /// Callback called before the node is deserialized.
-  void Function(Parsable)? onBeforeAssignFieldValues;
+  ParsableHook? onBeforeAssignFieldValues;
 
   /// Callback called after the node is deserialized.
-  void Function(Parsable)? onAfterAssignFieldValues;
+  ParsableHook? onAfterAssignFieldValues;
 }

lib/src/serialization/parse_node_proxy_factory.dart

@@ -0,0 +1,40 @@
+part of '../../kiota_abstractions.dart';
+
+/// A factory that creates a proxy for a [ParseNodeFactory] that allows for
+/// hooks to be added before and after the parsing of a [Parsable] object.
+abstract class ParseNodeProxyFactory implements ParseNodeFactory {
+  /// Creates a new instance of the [ParseNodeProxyFactory] class.
+  ParseNodeProxyFactory({
+    required ParseNodeFactory concrete,
+    ParsableHook? onBefore,
+    ParsableHook? onAfter,
+  })  : _concrete = concrete,
+        _onBefore = onBefore,
+        _onAfter = onAfter;
+
+  final ParseNodeFactory _concrete;
+  final ParsableHook? _onBefore;
+  final ParsableHook? _onAfter;
+
+  @override
+  String get validContentType => _concrete.validContentType;
+
+  @override
+  ParseNode getRootParseNode(String contentType, Uint8List content) {
+    final node = _concrete.getRootParseNode(contentType, content);
+
+    final originalBefore = node.onBeforeAssignFieldValues;
+    node.onBeforeAssignFieldValues = (parsable) {
+      originalBefore?.call(parsable);
+      _onBefore?.call(parsable);
+    };
+
+    final originalAfter = node.onAfterAssignFieldValues;
+    node.onAfterAssignFieldValues = (parsable) {
+      originalAfter?.call(parsable);
+      _onAfter?.call(parsable);
+    };
+
+    return node;
+  }
+}

lib/src/serialization/serialization_writer.dart

@@ -68,10 +68,10 @@ abstract class SerializationWriter {
   Uint8List getSerializedContent();
 
   /// Callback called before the serialization process starts.
-  void Function(Parsable)? onBeforeObjectSerialization;
+  ParsableHook? onBeforeObjectSerialization;
 
   /// Callback called after the serialization process ends.
-  void Function(Parsable)? onAfterObjectSerialization;
+  ParsableHook? onAfterObjectSerialization;
 
   /// Callback called right after the serialization process starts.
   void Function(Parsable, SerializationWriter)? onStartObjectSerialization;

lib/src/serialization/serialization_writer_proxy_factory.dart

@@ -0,0 +1,47 @@
+part of '../../kiota_abstractions.dart';
+
+abstract class SerializationWriterProxyFactory
+    implements SerializationWriterFactory {
+  SerializationWriterProxyFactory({
+    required SerializationWriterFactory concrete,
+    ParsableHook? onBefore,
+    ParsableHook? onAfter,
+    void Function(Parsable, SerializationWriter)? onStart,
+  })  : _concrete = concrete,
+        _onBefore = onBefore,
+        _onAfter = onAfter,
+        _onStart = onStart;
+
+  final SerializationWriterFactory _concrete;
+  final ParsableHook? _onBefore;
+  final ParsableHook? _onAfter;
+  final void Function(Parsable, SerializationWriter)? _onStart;
+
+  @override
+  String get validContentType => _concrete.validContentType;
+
+  @override
+  SerializationWriter getSerializationWriter(String contentType) {
+    final writer = _concrete.getSerializationWriter(contentType);
+
+    final originalBefore = writer.onBeforeObjectSerialization;
+    writer.onBeforeObjectSerialization = (p) {
+      _onBefore?.call(p);
+      originalBefore?.call(p);
+    };
+
+    final originalAfter = writer.onAfterObjectSerialization;
+    writer.onAfterObjectSerialization = (p) {
+      _onAfter?.call(p);
+      originalAfter?.call(p);
+    };
+
+    final originalStart = writer.onStartObjectSerialization;
+    writer.onStartObjectSerialization = (p, w) {
+      _onStart?.call(p, w);
+      originalStart?.call(p, w);
+    };
+
+    return writer;
+  }
+}