revoframework · Stoom · Aug 5, 2024
diff --git a/Extensions/Revo.Extensions.History/ChangeTracking/Model/EntityAttributeData.cs b/Extensions/Revo.Extensions.History/ChangeTracking/Model/EntityAttributeData.cs
@@ -1,6 +1,6 @@
 using System;
-using Newtonsoft.Json;
-using Newtonsoft.Json.Linq;
+using System.Collections.Generic;
+using System.Text.Json;
 using Revo.DataAccess.Entities;
 using Revo.Domain.ReadModel;
 
@@ -10,7 +10,7 @@ namespace Revo.Extensions.History.ChangeTracking.Model
     public class EntityAttributeData : EntityReadModel
     {
         private string attributeValueMapJson;
-        private JObject attributeValueMap;
+        private Dictionary<string, dynamic> attributeValueMap = [];
 
         public EntityAttributeData(Guid id, Guid? aggregateId, Guid? entityId)
         {
@@ -28,38 +28,42 @@ protected EntityAttributeData()
 
         public string AttributeValueMapJson
         {
-            get { return attributeValueMapJson ?? (attributeValueMapJson = attributeValueMap?.ToString(Formatting.None) ?? "{}"); }
+            get
+            {
+                return attributeValueMapJson ??= JsonSerializer.Serialize(attributeValueMap);
+            }
 
             private set
             {
                 attributeValueMapJson = value;
-                attributeValueMap = JObject.Parse(attributeValueMapJson);
+                if (string.IsNullOrWhiteSpace(attributeValueMapJson))
+                {
+                    attributeValueMap = [];
+                } 
+                else
+                {
+                    attributeValueMap = JsonSerializer.Deserialize<Dictionary<string, dynamic>>(attributeValueMapJson);
+                }
             }
         }
 
         public bool TryGetAttributeValue<T>(string attributeName, out T value)
         {
-            JToken token = null;
-            if (attributeValueMap?.TryGetValue(attributeName, out token) ?? false)
+            if (attributeValueMap.TryGetValue(attributeName, out dynamic token))
             {
-                value = (T)(dynamic)token;
+                value = (T)token;
                 return true;
             }
             else
             {
-                value = default(T);
+                value = default;
                 return false;
             }
         }
 
         public void SetAttributeValue<T>(string attributeName, T attributeValue)
         {
-            if (attributeValueMap == null)
-            {
-                attributeValueMap = new JObject();
-            }
-
-            attributeValueMap[attributeName] = attributeValue != null ? JToken.FromObject(attributeValue) : JValue.CreateNull();
+            attributeValueMap[attributeName] = attributeValue;
             attributeValueMapJson = null;
         }
 

diff --git a/Extensions/Revo.Extensions.History/ChangeTracking/TrackedChangeRecordConverter.cs b/Extensions/Revo.Extensions.History/ChangeTracking/TrackedChangeRecordConverter.cs
@@ -1,5 +1,5 @@
 using System;
-using Newtonsoft.Json;
+using System.Text.Json;
 using Revo.Extensions.History.ChangeTracking.Model;
 
 namespace Revo.Extensions.History.ChangeTracking
@@ -15,8 +15,8 @@ public TrackedChangeRecordConverter(IChangeDataTypeCache changeDataTypeCache)
 
         public TrackedChange FromRecord(TrackedChangeRecord record)
         {
-            Type changeDataType = changeDataTypeCache.GetClrChangeDataType(record.ChangeDataClassName);
-            ChangeData changeData = (ChangeData)JsonConvert.DeserializeObject(record.ChangeDataJson, changeDataType);
+            var changeDataType = changeDataTypeCache.GetClrChangeDataType(record.ChangeDataClassName);
+            var changeData = (ChangeData)JsonSerializer.Deserialize(record.ChangeDataJson, changeDataType);
 
             return new TrackedChange(
                 record.Id,
@@ -41,7 +41,7 @@ public TrackedChangeRecord ToRecord(TrackedChange change)
                 AggregateClassId = change.AggregateClassId,
                 AggregateId = change.AggregateId,
                 ChangeDataClassName = changeDataTypeCache.GetChangeDataTypeName(change.ChangeData.GetType()),
-                ChangeDataJson = JsonConvert.SerializeObject(change.ChangeData),
+                ChangeDataJson = JsonSerializer.Serialize(change.ChangeData, change.ChangeData.GetType()),
                 ChangeTime = change.ChangeTime,
                 EntityClassId = change.EntityClassId,
                 EntityId = change.EntityId

diff --git a/Extensions/Revo.Extensions.Notifications/NotificationSerializer.cs b/Extensions/Revo.Extensions.Notifications/NotificationSerializer.cs
@@ -1,51 +1,37 @@
-using System;
-using Newtonsoft.Json;
-using Newtonsoft.Json.Converters;
-using Newtonsoft.Json.Serialization;
+using System.Text.Json;
+using System.Text.Json.Serialization;
 
 namespace Revo.Extensions.Notifications
 {
-    public class NotificationSerializer : INotificationSerializer
+    public class NotificationSerializer(INotificationTypeCache notificationTypeCache) : INotificationSerializer
     {
-        private static readonly JsonSerializerSettings JsonSerializerSettings = new JsonSerializerSettings
+        private static readonly JsonSerializerOptions JsonSerializerSettings = new()
         {
-            ContractResolver = new DefaultContractResolver
-            {
-                NamingStrategy = new CamelCaseNamingStrategy
-                {
-                    ProcessDictionaryKeys = false
-                }
-            },
-            Formatting = Formatting.None
+            PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
         };
 
         static NotificationSerializer()
         {
-            JsonSerializerSettings.Converters.Add(new StringEnumConverter());
+            JsonSerializerSettings.Converters.Add(new JsonStringEnumConverter());
         }
 
-        private readonly INotificationTypeCache notificationTypeCache;
-
-        public NotificationSerializer(INotificationTypeCache notificationTypeCache)
-        {
-            this.notificationTypeCache = notificationTypeCache;
-        }
+        private readonly INotificationTypeCache notificationTypeCache = notificationTypeCache;
 
         public SerializedNotification ToJson(INotification notification)
         {
-            SerializedNotification serialized = new SerializedNotification()
+            var serialized = new SerializedNotification()
             {
                 NotificationClassName = notificationTypeCache.GetNotificationTypeName(notification.GetType()),
-                NotificationJson = JsonConvert.SerializeObject(notification, JsonSerializerSettings)
+                NotificationJson = JsonSerializer.Serialize(notification, notification.GetType(), JsonSerializerSettings)
             };
 
             return serialized;
         }
 
         public INotification FromJson(SerializedNotification serializedNotification)
         {
-            Type notificationType = notificationTypeCache.GetClrNotificationType(serializedNotification.NotificationClassName);
-            return (INotification)JsonConvert.DeserializeObject(serializedNotification.NotificationJson, notificationType, JsonSerializerSettings);
+            var notificationType = notificationTypeCache.GetClrNotificationType(serializedNotification.NotificationClassName);
+            return (INotification)JsonSerializer.Deserialize(serializedNotification.NotificationJson, notificationType, JsonSerializerSettings);
         }
     }
 }
diff --git a/...s/Tests/Revo.Extensions.History.Tests/ChangeTracking/TrackedChangeRecordConverterTests.cs b/...s/Tests/Revo.Extensions.History.Tests/ChangeTracking/TrackedChangeRecordConverterTests.cs
@@ -1,5 +1,7 @@
 using System;
-using Newtonsoft.Json.Linq;
+using System.Collections.Generic;
+using System.Text.Json;
+
 using NSubstitute;
 using Revo.Extensions.History.ChangeTracking;
 using Revo.Extensions.History.ChangeTracking.Model;
@@ -67,7 +69,7 @@ public void ToRecord_Result()
             Assert.Equal(change.EntityId, record.EntityId);
             Assert.Equal(change.EntityClassId, record.EntityClassId);
             Assert.Equal("TestChangeData", record.ChangeDataClassName);
-            Assert.Equal("bar", JObject.Parse(record.ChangeDataJson)["Foo"]);
+            Assert.Equal("bar", JsonSerializer.Deserialize<Dictionary<string, string>>(record.ChangeDataJson)["Foo"]);
             Assert.Equal(change.ChangeTime, record.ChangeTime);
         }
 

diff --git a/Providers/EF6/Revo.EF6/Configuration/EF6InfrastructureConfigurationSection.cs b/Providers/EF6/Revo.EF6/Configuration/EF6InfrastructureConfigurationSection.cs
@@ -1,5 +1,5 @@
 using System;
-using Newtonsoft.Json;
+using System.Text.Json;
 using Revo.Core.Configuration;
 
 namespace Revo.EF6.Configuration
@@ -14,6 +14,6 @@ public class EF6InfrastructureConfigurationSection : IRevoConfigurationSection
         public bool UseEventSourcedAggregateStore { get; set; }
         public bool UseCrudAggregateStore { get; set; }
 
-        public Func<JsonSerializerSettings, JsonSerializerSettings> CustomizeEventJsonSerializer { get; set; } = settings => settings;
+        public Func<JsonSerializerOptions, JsonSerializerOptions> CustomizeEventJsonSerializer { get; set; } = settings => settings;
     }
 }
diff --git a/Providers/EF6/Revo.EF6/Events/EF6EventsModule.cs b/Providers/EF6/Revo.EF6/Events/EF6EventsModule.cs
@@ -1,5 +1,5 @@
 using System;
-using Newtonsoft.Json;
+using System.Text.Json;
 using Ninject.Modules;
 using Revo.Core.Core;
 using Revo.DataAccess.Entities;
@@ -15,9 +15,9 @@ namespace Revo.EF6.Events
     [AutoLoadModule(false)]
     public class EF6AsyncEventsModule : NinjectModule
     {
-        private readonly Func<JsonSerializerSettings, JsonSerializerSettings> customizeEventJsonSerializer;
+        private readonly Func<JsonSerializerOptions, JsonSerializerOptions> customizeEventJsonSerializer;
 
-        public EF6AsyncEventsModule(Func<JsonSerializerSettings, JsonSerializerSettings> customizeEventJsonSerializer)
+        public EF6AsyncEventsModule(Func<JsonSerializerOptions, JsonSerializerOptions> customizeEventJsonSerializer)
         {
             this.customizeEventJsonSerializer = customizeEventJsonSerializer;
         }

diff --git a/Providers/EFCore/Revo.EFCore/Configuration/EFCoreInfrastructureConfigurationSection.cs b/Providers/EFCore/Revo.EFCore/Configuration/EFCoreInfrastructureConfigurationSection.cs
@@ -1,5 +1,5 @@
 using System;
-using Newtonsoft.Json;
+using System.Text.Json;
 using Revo.Core.Configuration;
 
 namespace Revo.EFCore.Configuration
@@ -14,6 +14,6 @@ public class EFCoreInfrastructureConfigurationSection : IRevoConfigurationSectio
         public bool UseEventSourcedAggregateStore { get; set; }
         public bool UseCrudAggregateStore { get; set; }
 
-        public Func<JsonSerializerSettings, JsonSerializerSettings> CustomizeEventJsonSerializer { get; set; } = settings => settings;
+        public Func<JsonSerializerOptions, JsonSerializerOptions> CustomizeEventJsonSerializer { get; set; } = settings => settings;
     }
 }
diff --git a/Providers/EFCore/Revo.EFCore/DataAccess/Conventions/LowerCaseConvention.cs b/Providers/EFCore/Revo.EFCore/DataAccess/Conventions/LowerCaseConvention.cs
@@ -19,7 +19,7 @@ public override void Finalize(ModelBuilder modelBuilder)
 
                 foreach (var property in entity.GetProperties())
                 {
-                    property.SetColumnName(property.GetColumnBaseName().ToLowerInvariant());
+                    property.SetColumnName(property.GetColumnName().ToLowerInvariant());
                 }
 
                 foreach (var key in entity.GetKeys())

diff --git a/Providers/EFCore/Revo.EFCore/DataAccess/Conventions/PrefixConvention.cs b/Providers/EFCore/Revo.EFCore/DataAccess/Conventions/PrefixConvention.cs
@@ -52,7 +52,7 @@ private void PrefixColumnNames(IMutableEntityType entity, string namespacePrefix
         {
             foreach (var property in entity.GetProperties())
             {
-                if (property.DeclaringEntityType != entity)
+                if (property.DeclaringType != entity)
                 {
                     continue;
                 }
@@ -64,7 +64,7 @@ private void PrefixColumnNames(IMutableEntityType entity, string namespacePrefix
                     ?? property.FieldInfo?.DeclaringType;
                 TablePrefixAttribute clrTypePrefixAttribute;
                 if (clrDeclaringType != null
-                    && property.DeclaringEntityType.ClrType != clrDeclaringType
+                    && property.DeclaringType.ClrType != clrDeclaringType
                     && (clrTypePrefixAttribute = GetTablePrefixAttribute(clrDeclaringType)) != null) //this might happen e.g. if clrDeclaringType is abstract but not 
                 {
                     propertyNamespacePrefix = clrTypePrefixAttribute.NamespacePrefix;
@@ -73,12 +73,12 @@ private void PrefixColumnNames(IMutableEntityType entity, string namespacePrefix
 
                 if (propertyColumnPrefix?.Length > 0)
                 {
-                    property.SetColumnName($"{propertyColumnPrefix}_{property.GetColumnBaseName()}");
+                    property.SetColumnName($"{propertyColumnPrefix}_{property.GetColumnName()}");
                 }
 
                 if (propertyNamespacePrefix?.Length > 0)
                 {
-                    property.SetColumnName($"{propertyNamespacePrefix}_{property.GetColumnBaseName()}");
+                    property.SetColumnName($"{propertyNamespacePrefix}_{property.GetColumnName()}");
                 }
             }
         }

diff --git a/Providers/EFCore/Revo.EFCore/DataAccess/Conventions/SnakeCaseColumnNamesConvention.cs b/Providers/EFCore/Revo.EFCore/DataAccess/Conventions/SnakeCaseColumnNamesConvention.cs
@@ -15,7 +15,7 @@ public override void Finalize(ModelBuilder modelBuilder)
             {
                 foreach (var property in entity.GetProperties())
                 {
-                    property.SetColumnName(ToSnakeCase(property.GetColumnBaseName()));
+                    property.SetColumnName(ToSnakeCase(property.GetColumnName()));
                 }
 
                 foreach (var key in entity.GetKeys())

diff --git a/Providers/EFCore/Revo.EFCore/Domain/ReadModelConvention.cs b/Providers/EFCore/Revo.EFCore/Domain/ReadModelConvention.cs
@@ -38,7 +38,7 @@ public override void Finalize(ModelBuilder modelBuilder)
                     var originalEntity = modelBuilder.Model.GetEntityTypes().FirstOrDefault(x => x.ClrType == attr.EntityType)
                                          ?? throw new InvalidOperationException($"Cannot map {entity.ClrType} as ReadModelForEntity for {attr.EntityType} because the latter is not part of the model.");
 
-                    entity.FindProperty("Id").SetColumnName(originalEntity.FindProperty("Id").GetColumnBaseName());
+                    entity.FindProperty("Id").SetColumnName(originalEntity.FindProperty("Id").GetColumnName());
                 }
             }
         }

diff --git a/Providers/EFCore/Revo.EFCore/Events/EFCoreEventsModule.cs b/Providers/EFCore/Revo.EFCore/Events/EFCoreEventsModule.cs
@@ -1,5 +1,5 @@
 using System;
-using Newtonsoft.Json;
+using System.Text.Json;
 using Ninject.Modules;
 using Revo.Core.Core;
 using Revo.Infrastructure;
@@ -13,9 +13,9 @@ namespace Revo.EFCore.Events
     [AutoLoadModule(false)]
     public class EFCoreAsyncEventsModule : NinjectModule
     {
-        private readonly Func<JsonSerializerSettings, JsonSerializerSettings> customizeEventJsonSerializer;
+        private readonly Func<JsonSerializerOptions, JsonSerializerOptions> customizeEventJsonSerializer;
 
-        public EFCoreAsyncEventsModule(Func<JsonSerializerSettings, JsonSerializerSettings> customizeEventJsonSerializer)
+        public EFCoreAsyncEventsModule(Func<JsonSerializerOptions, JsonSerializerOptions> customizeEventJsonSerializer)
         {
             this.customizeEventJsonSerializer = customizeEventJsonSerializer;
         }

diff --git a/Providers/EFCore/Tests/Revo.EFCore.Tests/Projections/EFCoreSyncProjectionHookTests.cs b/Providers/EFCore/Tests/Revo.EFCore.Tests/Projections/EFCoreSyncProjectionHookTests.cs
@@ -37,7 +37,7 @@ public async Task ProjectsBeforeCommit()
 
         await sut.OnBeforeCommitAsync();
 
-        projectionSubSystem.Received(1).ExecuteProjectionsAsync(
+        await projectionSubSystem.Received(1).ExecuteProjectionsAsync(
             Arg.Is<IReadOnlyCollection<IEventMessage<DomainAggregateEvent>>>(
                 evs =>  evs.SequenceEqual(events)),
             unitOfWork,
@@ -54,15 +54,15 @@ public async Task ProjectsOnlyAdditionalEvents()
         events.Add(new TestEvent().ToMessageDraft());
         await sut.OnBeforeCommitAsync();
 
-        projectionSubSystem.ReceivedWithAnyArgs(2).ExecuteProjectionsAsync(null, null, null);
+        await projectionSubSystem.ReceivedWithAnyArgs(2).ExecuteProjectionsAsync(null, null, null);
 
-        projectionSubSystem.Received(1).ExecuteProjectionsAsync(
+        await projectionSubSystem.Received(1).ExecuteProjectionsAsync(
             Arg.Is<IReadOnlyCollection<IEventMessage<DomainAggregateEvent>>>(
                 evs => evs.SequenceEqual(new[] { events[0] })),
             unitOfWork,
             Arg.Is<EFCoreEventProjectionOptions>(x => x.IsSynchronousProjection));
 
-        projectionSubSystem.Received(1).ExecuteProjectionsAsync(
+        await projectionSubSystem.Received(1).ExecuteProjectionsAsync(
             Arg.Is<IReadOnlyCollection<IEventMessage<DomainAggregateEvent>>>(
                 evs => evs.SequenceEqual(new[] { events[1] })),
             unitOfWork,
@@ -79,7 +79,7 @@ public async Task ProjectsAgainAfterCommitSucceeded()
         await sut.OnCommitSucceededAsync();
         await sut.OnBeforeCommitAsync();
 
-        projectionSubSystem.Received(2).ExecuteProjectionsAsync(
+        await projectionSubSystem.Received(2).ExecuteProjectionsAsync(
             Arg.Is<IReadOnlyCollection<IEventMessage<DomainAggregateEvent>>>(
                 evs => evs.SequenceEqual(events)),
             unitOfWork,
@@ -96,7 +96,7 @@ public async Task ProjectsAgainAfterCommitFailed()
         await sut.OnCommitFailedAsync();
         await sut.OnBeforeCommitAsync();
 
-        projectionSubSystem.Received(2).ExecuteProjectionsAsync(
+        await projectionSubSystem.Received(2).ExecuteProjectionsAsync(
             Arg.Is<IReadOnlyCollection<IEventMessage<DomainAggregateEvent>>>(
                 evs => evs.SequenceEqual(events)),
             unitOfWork,

diff --git a/Providers/EasyNetQ/Tests/Revo.EasyNetQ.Tests/EasyNetQBusTests.cs b/Providers/EasyNetQ/Tests/Revo.EasyNetQ.Tests/EasyNetQBusTests.cs
@@ -38,7 +38,7 @@ public async Task PublishAsync_Event()
 
             await sut.PublishAsync(event1);
 
-            pubSub.Received(1).PublishAsync(Arg.Is<IEventMessage<Event1>>(
+            await pubSub.Received(1).PublishAsync(Arg.Is<IEventMessage<Event1>>(
                 x => x.GetType().IsConstructedGenericType
                      && x.GetType().GetGenericTypeDefinition() == typeof(EventMessage<>)
                      && x.Event == event1
@@ -56,7 +56,7 @@ public async Task PublishAsync_EventMessage()
 
             await sut.PublishAsync(message);
 
-            pubSub.Received(1).PublishAsync(Arg.Is<IEventMessage<Event1>>(
+            await pubSub.Received(1).PublishAsync(Arg.Is<IEventMessage<Event1>>(
                 x => x.GetType().IsConstructedGenericType
                      && x.GetType().GetGenericTypeDefinition() == typeof(EventMessage<>)
                      && x.Event == event1

diff --git a/Providers/EasyNetQ/Tests/Revo.EasyNetQ.Tests/EasyNetQSubscriptionHandlerTests.cs b/Providers/EasyNetQ/Tests/Revo.EasyNetQ.Tests/EasyNetQSubscriptionHandlerTests.cs
@@ -32,7 +32,7 @@ public async Task HandleMessage()
 
             await sut.HandleMessageAsync(eventMessage);
 
-            eventBus.Received(1).PublishAsync(eventMessage);
+            await eventBus.Received(1).PublishAsync(eventMessage);
             currentTaskContext.Should().NotBeNull();
             currentTaskContext.Should().NotBe(prevTaskContext);
         }

diff --git a/Providers/EasyNetQ/Tests/Revo.EasyNetQ.Tests/EventTransportTests.cs b/Providers/EasyNetQ/Tests/Revo.EasyNetQ.Tests/EventTransportTests.cs
@@ -24,7 +24,7 @@ public async Task HandleAsync()
             var message = (IEventMessage<Event2>) EventMessage.FromEvent(new Event2(), new Dictionary<string, string>());
             await sut.HandleAsync(message, CancellationToken.None);
 
-            easyNetQBus.Received(1).PublishAsync<Event1>(message);
+            await easyNetQBus.Received(1).PublishAsync<Event1>(message);
         }
 
         private class Event1 : IEvent