Added LoadState to the same interface (for now)

src/Eventuous/AggregateState.cs

@@ -1,13 +1,31 @@
+using System;
+using System.Collections.Generic;
+using JetBrains.Annotations;
+
 namespace Eventuous {
     public abstract record AggregateState<T> where T : AggregateState<T> {
-        public abstract T When(object @event);
+        public virtual T When(object @event) {
+            var eventType = @event.GetType();
+            if (!_handlers.ContainsKey(eventType)) return (T) this;
+
+            return _handlers[eventType](@event);
+        }
+
+        [PublicAPI]
+        protected void On<TEvent>(Func<TEvent, T> handle) {
+            if (!_handlers.TryAdd(typeof(TEvent), x => handle((TEvent) x))) {
+                throw new InvalidOperationException($"Duplicate handler for {typeof(TEvent).Name}");
+            }
+        }
+
+        readonly Dictionary<Type, Func<object, T>> _handlers = new();
     }
-    
+
     public abstract record AggregateState<T, TId> : AggregateState<T>
         where T : AggregateState<T, TId>
         where TId : AggregateId {
         public TId Id { get; protected init; } = null!;
 
         internal T SetId(TId id) => (T) this with { Id = id };
     }
-}
+}

src/Eventuous/AggregateStore.cs

@@ -56,9 +56,30 @@ void Fold(StreamEvent streamEvent) {
 
                 aggregate!.Fold(evt);
             }
+        }
+
+        public async Task<T> LoadState<T, TId>(StreamName stream, CancellationToken cancellationToken)
+            where T : AggregateState<T, TId>, new() where TId : AggregateId {
+            var state = new T();
+
+            try {
+                await _eventStore.ReadStream(stream, StreamReadPosition.Start, Fold, cancellationToken).Ignore();
+            }
+            catch (Exceptions.StreamNotFound e) {
+                throw new Exceptions.StreamNotFound(stream);
+            }
 
-            object? Deserialize(StreamEvent streamEvent)
-                => _serializer.Deserialize(streamEvent.Data.AsSpan(), streamEvent.EventType);
+            return state;
+
+            void Fold(StreamEvent streamEvent) {
+                var evt = Deserialize(streamEvent);
+                if (evt == null) return;
+
+                state = state.When(evt);
+            }
         }
+
+        object? Deserialize(StreamEvent streamEvent)
+            => _serializer.Deserialize(streamEvent.Data.AsSpan(), streamEvent.EventType);
     }
 }

src/Eventuous/IAggregateStore.cs

@@ -7,5 +7,8 @@ public interface IAggregateStore {
         Task Store<T>(T entity, CancellationToken cancellationToken) where T : Aggregate;
 
         Task<T> Load<T>(string id, CancellationToken cancellationToken) where T : Aggregate, new();
+
+        Task<T> LoadState<T, TId>(StreamName stream, CancellationToken cancellationToken)
+            where T : AggregateState<T, TId>, new() where TId : AggregateId;
     }
 }