latest work

Author: halgari

src/NexusMods.EventSourcing.Abstractions/EntityIdDefinition.cs

@@ -58,7 +58,7 @@ public void WriteTo(Span<byte> span, IAccumulator accumulator)
 
 public class EntityDefinitionAccumulator : IAccumulator
 {
-    internal EntityId Id;
+    public EntityId Id;
 
     public void WriteTo(IBufferWriter<byte> writer, ISerializationRegistry registry)
     {

src/NexusMods.EventSourcing.Abstractions/EntityStructureRegistry.cs

@@ -38,6 +38,24 @@ public static void Register(IAttribute attribute)
         }
     }
 
+    /// <summary>
+    /// Returns all indexed attributes.
+    /// </summary>
+    /// <returns></returns>
+    public static IEnumerable<IIndexableAttribute> AllIndexableAttributes()
+    {
+        foreach (var (_, attributes) in _entityStructures)
+        {
+            foreach (var (_, attribute) in attributes)
+            {
+                if (attribute is IIndexableAttribute indexableAttribute && indexableAttribute.IndexedAttributeId != UInt128.Zero)
+                {
+                    yield return indexableAttribute;
+                }
+            }
+        }
+    }
+
     /// <summary>
     /// Registers an entity type in the global registry.
     /// </summary>

src/NexusMods.EventSourcing.Abstractions/IEventStore.cs

@@ -14,30 +14,37 @@ public interface IEventStore
     /// <param name="eventEntity"></param>
     /// <typeparam name="T"></typeparam>
     /// <returns></returns>
-    public TransactionId Add<T>(T eventEntity) where T : IEvent;
+    public TransactionId Add<T>(T eventEntity, (IIndexableAttribute, IAccumulator)[] indexed) where T : IEvent;
+
 
     /// <summary>
-    /// For each event within the given range (inclusive), for the given entity id, call the ingester.
+    /// Gets all events where the given attribute appears in the index with the given value. Transactions
+    /// will be between fromTx and toTx (inclusive on both ends)
     /// </summary>
-    /// <param name="entityId">The Entity Id to playback events for</param>
-    /// <param name="ingester">The ingester to handle the events</param>
-    /// <param name="reverse">If true, plays the events in reverse</param>
+    /// <param name="attr"></param>
+    /// <param name="value"></param>
+    /// <param name="ingester"></param>
+    /// <param name="fromTx"></param>
+    /// <param name="toTx"></param>
     /// <typeparam name="TIngester"></typeparam>
-    public void EventsForEntity<TIngester>(EntityId entityId, TIngester ingester, TransactionId fromId, TransactionId toId)
+    /// <typeparam name="TVal"></typeparam>
+    public void EventsForIndex<TIngester, TVal>(IIndexableAttribute<TVal> attr, TVal value, TIngester ingester,
+        TransactionId fromTx, TransactionId toTx)
         where TIngester : IEventIngester;
 
     /// <summary>
     /// For each event for the given entity id, call the ingester.
     /// </summary>
-    /// <param name="entityId">The Entity Id to playback events for</param>
+    /// <param name="value"></param>
     /// <param name="ingester">The ingester to handle the events</param>
-    /// <param name="reverse">If true, plays the events in reverse</param>
+    /// <param name="attr"></param>
     /// <typeparam name="TIngester"></typeparam>
-    public void EventsForEntity<TIngester>(EntityId entityId, TIngester ingester)
+    /// <typeparam name="TVal"></typeparam>
+    public void EventsForIndex<TIngester, TVal>(IIndexableAttribute<TVal> attr, TVal value, TIngester ingester)
         where TIngester : IEventIngester
 
     {
-        EventsForEntity(entityId, ingester, TransactionId.Min, TransactionId.Max);
+        EventsForIndex(attr, value, ingester, TransactionId.Min, TransactionId.Max);
     }
 
     /// <summary>
@@ -48,7 +55,7 @@ public void EventsForEntity<TIngester>(EntityId entityId, TIngester ingester)
     /// </summary>
     /// <param name="asOf"></param>
     /// <param name="entityId"></param>
-    /// <param name="revision"></param>
+    /// <param name="loadedDefinition"></param>
     /// <param name="loadedAttributes"></param>
     /// <returns></returns>
     public TransactionId GetSnapshot(TransactionId asOf, EntityId entityId,

src/NexusMods.EventSourcing/AEventStore.cs

@@ -102,6 +102,11 @@ protected ReadOnlySpan<byte> SerializeSnapshot(EntityId id, IDictionary<IAttribu
     public abstract TransactionId Add<T>(T eventEntity) where T : IEvent;
     public abstract void EventsForEntity<TIngester>(EntityId entityId, TIngester ingester, TransactionId fromId, TransactionId toId) where TIngester : IEventIngester;
 
+    public abstract TransactionId Add<T>(T eventEntity, (IIndexableAttribute, IAccumulator)[] indexed) where T : IEvent;
+
+    public abstract void EventsForIndex<TIngester, TVal>(IIndexableAttribute<TVal> attr, TVal value, TIngester ingester, TransactionId fromTx,
+        TransactionId toTx) where TIngester : IEventIngester;
+
     public abstract TransactionId GetSnapshot(TransactionId asOf, EntityId entityId, out IAccumulator loadedDefinition,
         out (IAttribute Attribute, IAccumulator Accumulator)[] loadedAttributes);
 

src/NexusMods.EventSourcing/EntityContext.cs

@@ -108,6 +108,7 @@ public TransactionId Add<TEvent>(TEvent newEvent) where TEvent : IEvent
     {
         lock (_lock)
         {
+
             var newId = store.Add(newEvent);
             asOf = newId;
 

tests/NexusMods.EventSourcing.Tests/AEventStoreTest.cs

@@ -21,14 +21,20 @@ public AEventStoreTest(T store)
     public void CanGetAndReturnEvents()
     {
         var enityId = EntityId<Loadout>.NewId();
-        Store.Add(new CreateLoadout(enityId, "Test"));
+        var entityIdAccumulator = IEntity.EntityIdAttribute.CreateAccumulator();
+        entityIdAccumulator.Id = enityId.Value;
+
+        var indexArray = new (IIndexableAttribute, IAccumulator)[] { (IEntity.EntityIdAttribute, entityIdAccumulator) };
+
+        Store.Add(new CreateLoadout(enityId, "Test"), indexArray);
+
         for (var i = 0; i < 10; i++)
         {
-            Store.Add(new RenameLoadout(enityId, $"Test {i}"));
+            Store.Add(new RenameLoadout(enityId, $"Test {i}"), indexArray);
         }
 
-        var accumulator = new EventAccumulator();
-        Store.EventsForEntity(enityId.Value, accumulator);
+        var accumulator = new EventIngester();
+        Store.EventsForIndex(IEntity.EntityIdAttribute, enityId.Value, accumulator);
         accumulator.Events.Count.Should().Be(11);
         accumulator.Events[0].Should().BeEquivalentTo(new CreateLoadout(enityId, "Test"));
         for (var i = 1; i < 11; i++)
@@ -69,7 +75,7 @@ public void CanGetSnapshots()
 
     }
 
-    private class EventAccumulator : IEventIngester
+    private class EventIngester : IEventIngester
     {
         public List<IEvent> Events { get; } = new();
         public bool Ingest(TransactionId _, IEvent @event)