Support for persistence to EventStoreDB. Fixes #3

src/DomainLib.Persistence.EventStore/DomainLib.Persistence.EventStore.csproj

@@ -0,0 +1,16 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>netstandard2.1</TargetFramework>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="EventStore.Client" Version="20.6.0" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\DomainLib.Persistence\DomainLib.Serialization.csproj" />
+    <ProjectReference Include="..\DomainLib\DomainLib.csproj" />
+  </ItemGroup>
+
+</Project>

src/DomainLib.Persistence.EventStore/EventStoreEventDataExtensions.cs

@@ -0,0 +1,13 @@
+using EventStore.ClientAPI;
+
+namespace DomainLib.Persistence.EventStore
+{
+    public static class EventStoreEventDataExtensions
+    {
+        public static EventData ToEventData(this IEventSerializer @eventSerializer, object @event)
+        {
+            var eventPersistenceData = eventSerializer.GetPersistenceData(@event);
+            return new EventData(eventPersistenceData.EventId, eventPersistenceData.EventName, eventPersistenceData.IsJsonBytes, eventPersistenceData.EventData, eventPersistenceData.EventMetadata);
+        }
+    }
+}

src/DomainLib.Persistence.EventStore/EventStoreEventsRepository.cs

@@ -0,0 +1,54 @@
+using EventStore.ClientAPI;
+using EventStore.ClientAPI.Exceptions;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+
+namespace DomainLib.Persistence.EventStore
+{
+    public class EventStoreEventsRepository : IEventsRepository
+    {
+        private readonly IEventStoreConnection _connection;
+        private readonly IEventSerializer _serializer;
+
+        public EventStoreEventsRepository(IEventStoreConnection connection, IEventSerializer serializer)
+        {
+            _connection = connection;
+            _serializer = serializer;
+        }
+
+        public async Task<long> SaveEventsAsync<TEvent>(string streamName, long expectedStreamVersion, IEnumerable<TEvent> events)
+        {
+            var eventDatas = events.Select(e => _serializer.ToEventData(e));
+
+            // TODO: Handle failure cases
+            var writeResult = await _connection.AppendToStreamAsync(streamName, expectedStreamVersion, eventDatas);
+
+            return writeResult.NextExpectedVersion;
+        }
+
+        public async Task<IEnumerable<TEvent>> LoadEventsAsync<TEvent>(string streamName)
+        {
+            // TODO: Handle large streams in  batches
+            var eventsSlice = await _connection.ReadStreamEventsForwardAsync(streamName, 0, ClientApiConstants.MaxReadSize, false);
+
+            switch (eventsSlice.Status)
+            {
+                case SliceReadStatus.Success:
+                    break;
+                case SliceReadStatus.StreamNotFound:
+                    // TOOO: Better exception
+                    throw new InvalidOperationException($"Unable to find stream {streamName}");
+                case SliceReadStatus.StreamDeleted:
+                    throw new StreamDeletedException(streamName);
+                default:
+                    throw new ArgumentOutOfRangeException();
+            }
+
+            var events = eventsSlice.Events;
+
+            return events.Select(e => _serializer.DeserializeEvent<TEvent>(e.OriginalEvent.Data, e.OriginalEvent.EventType));
+        }
+    }
+}

src/DomainLib.Persistence/DomainLib.Serialization.csproj

@@ -0,0 +1,15 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>netstandard2.1</TargetFramework>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="System.Text.Json" Version="4.7.1" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\DomainLib\DomainLib.csproj" />
+  </ItemGroup>
+
+</Project>

src/DomainLib.Persistence/InvalidEventTypeException.cs

@@ -0,0 +1,46 @@
+using System;
+using System.Runtime.Serialization;
+
+namespace DomainLib.Serialization
+{
+    [Serializable]
+    public class InvalidEventTypeException : Exception
+    {
+        public string SerializedEventType { get; }
+        public string ClrTypeName { get; }
+
+        public InvalidEventTypeException(string serializedEventType, string clrTypeName)
+        {
+            SerializedEventType = serializedEventType;
+            ClrTypeName = clrTypeName;
+        }
+
+        public InvalidEventTypeException(string message, string serializedEventType, string clrTypeName) 
+            : base(message)
+        {
+            SerializedEventType = serializedEventType;
+            ClrTypeName = clrTypeName;
+        }
+
+        public InvalidEventTypeException(string message, string serializedEventType, string clrTypeName, Exception inner) 
+            : base(message, inner)
+        {
+            SerializedEventType = serializedEventType;
+            ClrTypeName = clrTypeName;
+        }
+
+        protected InvalidEventTypeException(SerializationInfo info, StreamingContext context) 
+            : base(info, context)
+        {
+            if (info == null)
+            {
+                throw new ArgumentNullException(nameof(info));
+            }
+
+            info.AddValue(nameof(ClrTypeName), ClrTypeName);
+            info.AddValue(nameof(SerializedEventType), SerializedEventType);
+
+            base.GetObjectData(info, context);
+        }
+    }
+}

src/DomainLib.Persistence/JsonEventPersistenceData.cs

@@ -0,0 +1,23 @@
+using System;
+using DomainLib.Persistence;
+
+namespace DomainLib.Serialization
+{
+    public readonly struct JsonEventPersistenceData : IEventPersistenceData
+    {
+        public JsonEventPersistenceData(Guid eventId, string eventName, byte[] eventData, byte[] eventMetadata) : this()
+        {
+            EventId = eventId;
+            EventName = eventName;
+            IsJsonBytes = true;
+            EventData = eventData;
+            EventMetadata = eventMetadata;
+        }
+
+        public Guid EventId { get; }
+        public string EventName { get; }
+        public bool IsJsonBytes { get; }
+        public byte[] EventData { get; }
+        public byte[] EventMetadata { get; }
+    }
+}

src/DomainLib.Persistence/JsonEventSerializer.cs

@@ -0,0 +1,59 @@
+using DomainLib.Aggregates;
+using DomainLib.Persistence;
+using System;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+namespace DomainLib.Serialization
+{
+    public class JsonEventSerializer : IEventSerializer
+    {
+        private readonly JsonSerializerOptions _options;
+        private readonly IEventNameMap _eventNameMap = new EventNameMap();
+
+        public JsonEventSerializer()
+        {
+            _options = new JsonSerializerOptions
+            {
+                WriteIndented = true,
+                AllowTrailingCommas = false,
+            };
+        }
+
+        public JsonEventSerializer(JsonSerializerOptions options)
+        {
+            _options = options;
+        }
+
+        public void RegisterConverter(JsonConverter customConverter)
+        {
+            _options.Converters.Add(customConverter);
+        }
+
+        public void RegisterEventTypeMappings(IEventNameMap eventNameMap)
+        {
+            _eventNameMap.Merge(eventNameMap);
+        }
+
+        public IEventPersistenceData GetPersistenceData(object @event)
+        {
+            var eventName = _eventNameMap.GetEventNameForClrType(@event.GetType());
+            return new JsonEventPersistenceData(Guid.NewGuid(), eventName, JsonSerializer.SerializeToUtf8Bytes(@event, _options), null);
+        }
+
+        public TEvent DeserializeEvent<TEvent>(byte[] eventData, string eventName)
+        {
+            var clrType = _eventNameMap.GetClrTypeForEventName(eventName);
+
+            var evt = JsonSerializer.Deserialize(eventData, clrType, _options);
+
+            if (evt is TEvent @event)
+            {
+                return @event;
+            }
+
+            var runtTimeType = typeof(TEvent);
+            throw new InvalidEventTypeException($"Cannot cast event of type {eventName} to {runtTimeType.FullName}", eventName, runtTimeType.FullName);
+        }
+    }
+}

src/DomainLib.Tests/Aggregates/ApplyEventRouterTests.cs

@@ -4,6 +4,12 @@
 
 namespace DomainLib.Tests.Aggregates
 {
+    public static class EventNames
+    {
+        public const string SomethingHappened = "SomethingHappened";
+        public const string SomethingElseHappened = "SomethingElseHappened";
+    }
+
     [TestFixture]
     public class ApplyEventRouterTests
     {
@@ -77,10 +83,27 @@ public void DefaultEventRouteIsInvokedWhenSpecified()
             Assert.That(newState.OtherState, Is.Null);
         }
 
+        [Test]
+        public void EventNamesAreMappedWhenEventRoutesAreAdded()
+        {
+            var builder = new ApplyEventRouterBuilder<MyAggregateRoot, IEvent>();
+            builder.Add<SomethingHappened>((agg, e) => agg.ApplyEvent(e));
+            builder.Add<SomethingElseHappened>((agg, e) => agg.ApplyEvent(e));
+
+            var router = builder.Build();
+
+            Assert.That(router.EventNameMap.GetEventNameForClrType(typeof(SomethingHappened)),
+                Is.EqualTo(EventNames.SomethingHappened));
+
+            Assert.That(router.EventNameMap.GetEventNameForClrType(typeof(SomethingElseHappened)),
+                        Is.EqualTo(EventNames.SomethingElseHappened));
+        }
+
         private interface IEvent
         {
         }
 
+        [EventName(EventNames.SomethingHappened)]
         private class SomethingHappened : IEvent
         {
             public SomethingHappened(string state)
@@ -90,7 +113,8 @@ public SomethingHappened(string state)
 
             public string State { get; }
         }
-
+
+        [EventName(EventNames.SomethingElseHappened)]
         private class SomethingElseHappened : IEvent
         {
             public SomethingElseHappened(string otherState)