Add store item logic to EventStore

.github/workflows/build.yml

@@ -7,7 +7,7 @@ on:
     branches: [ "main" ]
 
 env:
-  PACKAGE_VERSION: 0.1.2
+  PACKAGE_VERSION: 0.1.3
 
 jobs:
 

CloudFabric.EventSourcing.AspNet/CloudFabric.EventSourcing.AspNet.CosmosDb/Extensions/ServiceCollectionExtensions.cs

@@ -14,7 +14,8 @@ public static IEventSourcingBuilder AddCosmosDbEventStore(
             string connectionString,
             CosmosClientOptions cosmosClientOptions,
             string databaseId,
-            string containerId,
+            string eventsContainerId,
+            string itemsContainerId,
             CosmosClient leaseClient,
             string leaseDatabaseId,
             string leaseContainerId,
@@ -23,13 +24,13 @@ string processorName
         {
             var cosmosClient = new CosmosClient(connectionString, cosmosClientOptions);
 
-            var eventStore = new CosmosDbEventStore(cosmosClient, databaseId, containerId);
+            var eventStore = new CosmosDbEventStore(cosmosClient, databaseId, eventsContainerId, itemsContainerId);
             eventStore.Initialize().Wait();
 
             var eventStoreObserver = new CosmosDbEventStoreChangeFeedObserver(
                 cosmosClient,
                 databaseId,
-                containerId,
+                eventsContainerId,
                 leaseClient,
                 leaseDatabaseId,
                 leaseContainerId,
@@ -52,10 +53,11 @@ public static IEventSourcingBuilder AddCosmosDbEventStore(
             this IServiceCollection services,
             CosmosClient client,
             string databaseId,
-            string containerId
+            string eventsContainerId,
+            string itemsContainerId
         )
         {
-            var eventStore = new CosmosDbEventStore(client, databaseId, containerId);
+            var eventStore = new CosmosDbEventStore(client, databaseId, eventsContainerId, itemsContainerId);
             eventStore.Initialize().Wait();
 
             return new EventSourcingBuilder

CloudFabric.EventSourcing.AspNet/CloudFabric.EventSourcing.AspNet.InMemory/Extensions/ServiceCollectionExtensions.cs

@@ -1,3 +1,4 @@
+using System.Runtime.CompilerServices;
 using CloudFabric.EventSourcing.Domain;
 using CloudFabric.EventSourcing.EventStore.InMemory;
 using CloudFabric.Projections;
@@ -11,10 +12,11 @@ public static class ServiceCollectionExtensions
     {
         public static IEventSourcingBuilder AddInMemoryEventStore(
             this IServiceCollection services,
-            Dictionary<(Guid, string), List<string>> eventsContainer
+            Dictionary<(Guid, string), List<string>> eventsContainer,
+            Dictionary<(string, string), string> itemsContainer
         )
         {
-            var eventStore = new InMemoryEventStore(eventsContainer);
+            var eventStore = new InMemoryEventStore(eventsContainer, itemsContainer);
             eventStore.Initialize().Wait();
 
             // add events observer for projections
@@ -32,6 +34,14 @@ public static IEventSourcingBuilder AddInMemoryEventStore(
             };
         }
 
+        public static IEventSourcingBuilder AddInMemoryEventStore(this IServiceCollection services)
+        {
+            return services.AddInMemoryEventStore(
+                new Dictionary<(Guid, string), List<string>>(),
+                new Dictionary<(string, string), string>()
+            );
+        }
+
         public static IEventSourcingBuilder AddRepository<TRepo>(this IEventSourcingBuilder builder)
             where TRepo : class
         {

CloudFabric.EventSourcing.AspNet/CloudFabric.EventSourcing.AspNet.Postgresql/Extensions/ServiceCollectionExtensions.cs

@@ -1,4 +1,5 @@
 using CloudFabric.EventSourcing.Domain;
+using CloudFabric.EventSourcing.EventStore.Enums;
 using CloudFabric.EventSourcing.EventStore.Postgresql;
 using CloudFabric.Projections;
 using CloudFabric.Projections.Postgresql;
@@ -12,10 +13,11 @@ public static class ServiceCollectionExtensions
         public static IEventSourcingBuilder AddPostgresqlEventStore(
             this IServiceCollection services,
             string eventsConnectionString,
-            string tableName
+            string eventTableName,
+            string itemTableName
         )
         {
-            var eventStore = new PostgresqlEventStore(eventsConnectionString, tableName);
+            var eventStore = new PostgresqlEventStore(eventsConnectionString, eventTableName, itemTableName);
             eventStore.Initialize().Wait();
 
             // add events observer for projections
@@ -33,6 +35,22 @@ string tableName
             };
         }
 
+        /// <summary>
+        /// This extension overload initialize event store with default item event store table name.
+        /// </summary>
+        public static IEventSourcingBuilder AddPostgresqlEventStore(
+            this IServiceCollection services,
+            string eventsConnectionString,
+            string eventTableName
+        )
+        {
+            return services.AddPostgresqlEventStore(
+                eventsConnectionString,
+                eventTableName,
+                string.Concat(eventTableName, ItemEventStoreNameAdding.TableNameAdding)
+            );
+        }
+
         public static IEventSourcingBuilder AddRepository<TRepo>(this IEventSourcingBuilder builder)
             where TRepo : class
         {

CloudFabric.EventSourcing.EventStore/Enums/ItemEventStoreNameAdding.cs

@@ -0,0 +1,6 @@
+namespace CloudFabric.EventSourcing.EventStore.Enums;
+
+public static class ItemEventStoreNameAdding
+{
+    public const string TableNameAdding = "-item";
+}

CloudFabric.EventSourcing.EventStore/EventSerializerOptions.cs → CloudFabric.EventSourcing.EventStore/EventStoreSerializerOptions.cs

@@ -2,7 +2,7 @@
 
 namespace CloudFabric.EventSourcing.EventStore;
 
-public static class EventSerializerOptions
+public static class EventStoreSerializerOptions
 {
     public static JsonSerializerOptions Options
     {

CloudFabric.EventSourcing.EventStore/IEventStore.cs

@@ -23,4 +23,8 @@ Task<bool> AppendToStreamAsync(
     Task DeleteAll(CancellationToken cancellationToken = default);
 
     Task<bool> HardDeleteAsync(Guid streamId, string partitionKey, CancellationToken cancellationToken = default);
+
+    Task UpsertItem<T>(string id, string partitionKey, T item, CancellationToken cancellationToken = default);
+
+    Task<T?> LoadItem<T>(string id, string partitionKey, CancellationToken cancellationToken = default);
 }

CloudFabric.EventSourcing.EventStore/Persistence/EventWrapper.cs

@@ -36,7 +36,7 @@ public IEvent GetEvent()
                 throw new Exception("Couldn't find event type. Make sure it's in correct namespace.");
             }
 
-            var e = (IEvent?)EventData.Deserialize(eventType, EventSerializerOptions.Options);
+            var e = (IEvent?)EventData.Deserialize(eventType, EventStoreSerializerOptions.Options);
 
             if (e == null)
             {

CloudFabric.EventSourcing.EventStore/Persistence/ItemWrapper.cs

@@ -0,0 +1,15 @@
+using System.Text.Json.Serialization;
+
+namespace CloudFabric.EventSourcing.EventStore.Persistence;
+
+public class ItemWrapper
+{
+    [JsonPropertyName("id")]
+    public string? Id { get; set; }
+
+    [JsonPropertyName("partition_key")]
+    public string? PartitionKey { get; set; }
+
+    [JsonPropertyName("data")]
+    public string? ItemData { get; set; }
+}

CloudFabric.EventSourcing.Tests/Domain/TestItem.cs

@@ -0,0 +1,19 @@
+namespace CloudFabric.EventSourcing.Tests.Domain;
+
+public class TestItem
+{
+    public Guid Id { get; set; }
+
+    public string Name { get; set; }
+
+    public Dictionary<string, TestNestedItemClass> Properties { get; set; }
+}
+
+public class TestNestedItemClass
+{
+    public Guid Id { get; set; } = Guid.NewGuid();
+
+    public string Name { get; set; } = nameof(Name).ToLowerInvariant();
+
+    public DateTime date { get; } = DateTime.MinValue;
+}

CloudFabric.EventSourcing.Tests/ItemTests.cs

@@ -0,0 +1,102 @@
+using CloudFabric.EventSourcing.EventStore;
+using CloudFabric.EventSourcing.Tests.Domain;
+using FluentAssertions;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+namespace CloudFabric.EventSourcing.Tests;
+public abstract class ItemTests
+{
+    protected abstract Task<IEventStore> GetEventStore();
+    private IEventStore _eventStore;
+
+    [TestInitialize]
+    public async Task Initialize()
+    {
+        _eventStore = await GetEventStore();
+    }
+
+    [TestCleanup]
+    public async Task Cleanup()
+    {
+        await _eventStore.DeleteAll();
+    }
+
+    [TestMethod]
+    public async Task SaveItem()
+    {
+        var item = new TestItem
+        {
+            Id = Guid.NewGuid(),
+            Name = "Item1",
+            Properties = new Dictionary<string, TestNestedItemClass>
+            {
+                { Guid.NewGuid().ToString(), new TestNestedItemClass() },
+                { Guid.NewGuid().ToString(), new TestNestedItemClass() }
+            }
+        };
+
+        Func<Task> action = async () => await _eventStore.UpsertItem($"{item.Id}{item.Name}", $"{item.Id}{item.Name}", item);
+        await action.Should().NotThrowAsync();
+    }
+
+    [TestMethod]
+    public async Task LoadItem()
+    {
+        var item = new TestItem
+        {
+            Id = Guid.NewGuid(),
+            Name = "Item1",
+            Properties = new Dictionary<string, TestNestedItemClass>
+            {
+                { Guid.NewGuid().ToString(), new TestNestedItemClass() }
+            }
+        };
+
+        await _eventStore.UpsertItem($"{item.Id}{item.Name}", $"{item.Id}{item.Name}", item);
+
+        var loadedItem = await _eventStore.LoadItem<TestItem>($"{item.Id}{item.Name}", $"{item.Id}{item.Name}");
+
+        loadedItem.Id.Should().Be(item.Id);
+        loadedItem.Name.Should().Be(item.Name);
+        loadedItem.Properties.Keys.Should().BeEquivalentTo(item.Properties.Keys);
+        loadedItem.Properties.Values.Should().BeEquivalentTo(item.Properties.Values);
+    }
+
+    [TestMethod]
+    public async Task LoadItem_NullIfNotFound()
+    {
+        var loadedItem = await _eventStore.LoadItem<TestItem>($"{Guid.NewGuid()}", $"{Guid.NewGuid()}");
+
+        loadedItem.Should().BeNull();
+    }
+
+    [TestMethod]
+    public async Task UpdateItem()
+    {
+        var item = new TestItem
+        {
+            Id = Guid.NewGuid(),
+            Name = "Item1",
+            Properties = new Dictionary<string, TestNestedItemClass>
+            {
+                { Guid.NewGuid().ToString(), new TestNestedItemClass() },
+                { Guid.NewGuid().ToString(), new TestNestedItemClass() }
+            }
+        };
+
+        await _eventStore.UpsertItem($"{item.Id}{item.Name}", $"{item.Id}{item.Name}", item);
+
+        string propertyGuid = Guid.NewGuid().ToString();
+
+        item.Properties = new()
+        {
+            { propertyGuid, new TestNestedItemClass() }
+        };
+
+        Func<Task> action = async () => await _eventStore.UpsertItem($"{item.Id}{item.Name}", $"{item.Id}{item.Name}", item);
+        await action.Should().NotThrowAsync();
+
+        var updatedItem = await _eventStore.LoadItem<TestItem>($"{item.Id}{item.Name}", $"{item.Id}{item.Name}");
+        updatedItem.Properties.ContainsKey(propertyGuid).Should().BeTrue();
+    }
+}