Added domain event context

samples/EasyWay.Samples/Domain/CreatedSampleAggragete.cs

@@ -1,7 +1,7 @@
 namespace EasyWay.Samples.Domain
 {
-    public class CreatedSampleAggragete : DomainEvent
+    public sealed class CreatedSampleAggragete : DomainEvent
     {
-        public Guid Id { get; } = Guid.NewGuid();
+        public string test { get; } = "TEST";
     }
 }

samples/EasyWay.Samples/Events/SampleEventHandler1.cs

@@ -1,10 +1,11 @@
-using EasyWay.Samples.Domain;
+using EasyWay.Events.DomainEvents;
+using EasyWay.Samples.Domain;
 
 namespace EasyWay.Samples.Events
 {
     public sealed class SampleEventHandler1 : DomainEventHandler<CreatedSampleAggragete>
     {
-        public sealed override Task Handle(CreatedSampleAggragete domainEvent)
+        public override Task Handle(CreatedSampleAggragete domainEvent, Context context)
         {
             return Task.CompletedTask;
         }

samples/EasyWay.Samples/Events/SampleEventHandler2.cs

@@ -1,10 +1,11 @@
-using EasyWay.Samples.Domain;
+using EasyWay.Events.DomainEvents;
+using EasyWay.Samples.Domain;
 
 namespace EasyWay.Samples.Events
 {
     public sealed class SampleEventHandler2 : DomainEventHandler<CreatedSampleAggragete>
     {
-        public sealed override Task Handle(CreatedSampleAggragete domainEvent)
+        public override Task Handle(CreatedSampleAggragete domainEvent, Context context)
         {
             return Task.CompletedTask;
         }

source/EasyWay.EntityFrameworkCore/Internals/DomainEvents/DomainEventsAccessor.cs

@@ -11,7 +11,7 @@ public DomainEventsAccessor(DbContext dbContext)
             _dbContext = dbContext;
         }
 
-        public IReadOnlyCollection<DomainEvent> GetAllDomainEvents()
+        public IReadOnlyCollection<DomainEventContext> GetAllDomainEvents()
         {
             var domainEntities = _dbContext.ChangeTracker
                 .Entries<Entity>()

source/EasyWay/DomainEvent.cs

@@ -1,21 +1,10 @@
-using EasyWay.Internals.Clocks;
-using EasyWay.Internals.GuidGenerators;
-
-namespace EasyWay
+namespace EasyWay
 {
     /// <summary>
     /// Represents an event
     /// </summary>
     public abstract class DomainEvent
     {
-        internal Guid EventId { get; }
-
-        internal DateTime OccurrenceOn { get; }
-
-        protected DomainEvent()
-        {
-            EventId = GuidGenerator.New;
-            OccurrenceOn = InternalClock.UtcNow;
-        }
+        protected DomainEvent() { }
     }
 }

source/EasyWay/DomainEventHandler.cs

@@ -1,4 +1,6 @@
-namespace EasyWay
+using EasyWay.Events.DomainEvents;
+
+namespace EasyWay
 {
     /// <summary>
     /// Defines a handler for an event
@@ -11,6 +13,6 @@ public abstract class DomainEventHandler<TDomainEvent>
         /// Handles an event
         /// </summary>
         /// <param name="domainEvent">Event</param>
-        public abstract Task Handle(TDomainEvent domainEvent);
+        public abstract Task Handle(TDomainEvent domainEvent, Context context);
     }
 }

source/EasyWay/Entity.cs

@@ -1,4 +1,5 @@
 using EasyWay.Internals.BusinessRules;
+using EasyWay.Internals.Clocks;
 using EasyWay.Internals.DomainEvents;
 using EasyWay.Internals.GuidGenerators;
 using System.Diagnostics.CodeAnalysis;
@@ -9,9 +10,9 @@ public abstract class Entity : IEquatable<Entity>, IEqualityComparer<Entity>
     {
         internal Guid Id { get; private set; } = GuidGenerator.New;
 
-        private List<DomainEvent> _domainEvents = new List<DomainEvent>();
+        private List<DomainEventContext> _domainEvents = new List<DomainEventContext>();
 
-        internal IReadOnlyCollection<DomainEvent> DomainEvents => _domainEvents.AsReadOnly();
+        internal IReadOnlyCollection<DomainEventContext> DomainEvents => _domainEvents.AsReadOnly();
 
         internal void ClearDomainEvents() => _domainEvents.Clear();
 
@@ -33,7 +34,16 @@ protected void Add<TDomainEvent>(TDomainEvent domainEvent)
                 throw new DomainEventCannotBeNullException<TDomainEvent>();
             }
 
-            _domainEvents.Add(domainEvent);
+            var domainEventContext = new DomainEventContext()
+            {
+                EventId = GuidGenerator.New,
+                AggragetRootId = Id, // TODO what when we have object graph
+                EntityId = Id,
+                OccurrenceOnUtc = InternalClock.UtcNow,
+                DomainEvent = domainEvent,
+            };
+
+            _domainEvents.Add(domainEventContext);
         }
 
         public static bool operator ==(Entity x, Entity y) => EntityEquals(x, y);

source/EasyWay/Events/DomainEvents/Context.cs

@@ -0,0 +1,25 @@
+namespace EasyWay.Events.DomainEvents
+{
+    public sealed class Context
+    {
+        public Guid EventId { get; }
+
+        public Guid AggragetRootId { get; }
+
+        public Guid EntityId { get; }
+
+        public DateTime OccurrenceOnUtc { get; }
+
+        internal Context(
+            Guid eventId,
+            Guid aggragetRootId,
+            Guid entityId,
+            DateTime occurrenceOnUtc)
+        {
+            EventId = eventId;
+            AggragetRootId = aggragetRootId;
+            EntityId = entityId;
+            OccurrenceOnUtc = occurrenceOnUtc;
+        }
+    }
+}

source/EasyWay/Internals/DomainEvents/DomainEventBulkPublisher.cs

@@ -9,12 +9,11 @@ public DomainEventBulkPublisher(IDomainEventPublisher domainEventPublisher)
             _domainEventPublisher = domainEventPublisher;
         }
 
-        public async Task Publish<TDomainEvent>(IEnumerable<TDomainEvent> domainEvents) 
-            where TDomainEvent : DomainEvent
+        public async Task Publish(IEnumerable<DomainEventContext> domainEventContexts) 
         {
-            foreach (var domainEvent in domainEvents) 
+            foreach (var domainEventContext in domainEventContexts) 
             {
-                await _domainEventPublisher.Publish(domainEvent).ConfigureAwait(false);
+                await _domainEventPublisher.Publish(domainEventContext).ConfigureAwait(false);
             }
         }
     }

source/EasyWay/Internals/DomainEvents/DomainEventContext.cs

@@ -0,0 +1,15 @@
+namespace EasyWay.Internals.DomainEvents
+{
+    internal sealed class DomainEventContext
+    {
+        internal required Guid EventId { get; init; }
+
+        internal required Guid AggragetRootId { get; init; }
+
+        internal required Guid EntityId { get; init; }
+
+        internal required DateTime OccurrenceOnUtc { get; init; }
+
+        internal required DomainEvent DomainEvent { get; init; }
+    }
+}

source/EasyWay/Internals/DomainEvents/DomainEventContextDispacher.cs

@@ -16,30 +16,30 @@ public DomainEventContextDispacher(
 
         public async Task Dispach()
         {
-            var domainEvents = _context.GetAllDomainEvents();
+            var domainEventContexts = _context.GetAllDomainEvents();
 
-            if (!domainEvents.Any()) 
+            if (!domainEventContexts.Any()) 
             {
                 return;
             }
 
             _context.ClearAllDomainEvents();
 
             await _publisher
-                .Publish(domainEvents)
+                .Publish(domainEventContexts)
                 .ConfigureAwait(false);
 
-            domainEvents = _context.GetAllDomainEvents();
+            domainEventContexts = _context.GetAllDomainEvents();
 
-            while (domainEvents.Any()) 
+            while (domainEventContexts.Any()) 
             {
                 _context.ClearAllDomainEvents();
 
                 await _publisher
-                    .Publish(domainEvents)
+                    .Publish(domainEventContexts)
                     .ConfigureAwait(false);
 
-                domainEvents = _context.GetAllDomainEvents();
+                domainEventContexts = _context.GetAllDomainEvents();
             }
         }
     }

source/EasyWay/Internals/DomainEvents/DomainEventPublisher.cs

@@ -1,4 +1,5 @@
-using Microsoft.Extensions.DependencyInjection;
+using EasyWay.Events.DomainEvents;
+using Microsoft.Extensions.DependencyInjection;
 
 namespace EasyWay.Internals.DomainEvents
 {
@@ -11,18 +12,25 @@ public DomainEventPublisher(IServiceProvider serviceProvider)
             _serviceProvider = serviceProvider;
         }
 
-        public async Task Publish<TEvent>(TEvent @event)
-            where TEvent : DomainEvent
+        public async Task Publish(DomainEventContext domainEventContext)
         {
-            var handlerType = typeof(DomainEventHandler<>).MakeGenericType(@event.GetType());
+            var domainEvent = domainEventContext.DomainEvent;
+
+            var handlerType = typeof(DomainEventHandler<>).MakeGenericType(domainEvent.GetType());
 
             var eventHandlers = _serviceProvider.GetServices(handlerType);
 
+            var context = new Context(
+                eventId: domainEventContext.EntityId,
+                aggragetRootId: domainEventContext.AggragetRootId,
+                entityId: domainEventContext.EntityId,
+                occurrenceOnUtc: domainEventContext.OccurrenceOnUtc);
+
             foreach (var eventHandler in eventHandlers)
             {
                 await (Task)handlerType
-                    .GetMethod(nameof(DomainEventHandler<TEvent>.Handle))?
-                    .Invoke(eventHandler, new object[] { @event });
+                    .GetMethod(nameof(DomainEventHandler<DomainEvent>.Handle))?
+                    .Invoke(eventHandler, new object[] { domainEvent, context });
             }
         }
     }

source/EasyWay/Internals/DomainEvents/IDomainEventBulkPublisher.cs

@@ -2,7 +2,6 @@
 {
     internal interface IDomainEventBulkPublisher
     {
-        Task Publish<TDomainEvent>(IEnumerable<TDomainEvent> domainEvents)
-            where TDomainEvent : DomainEvent;
+        Task Publish(IEnumerable<DomainEventContext> domainEventContexts);
     }
 }

source/EasyWay/Internals/DomainEvents/IDomainEventPublisher.cs

@@ -2,7 +2,6 @@
 {
     internal interface IDomainEventPublisher
     {
-        Task Publish<TEvent>(TEvent @event)
-            where TEvent : DomainEvent;
+        Task Publish(DomainEventContext domainEventContext);
     }
 }

source/EasyWay/Internals/DomainEvents/IDomainEventsContext.cs

@@ -2,7 +2,7 @@
 {
     internal interface IDomainEventsContext
     {
-        IReadOnlyCollection<DomainEvent> GetAllDomainEvents();
+        IReadOnlyCollection<DomainEventContext> GetAllDomainEvents();
 
         void ClearAllDomainEvents();
     }

source/EasyWay/Internals/GuidGenerators/GuidGenerator.cs

@@ -12,6 +12,6 @@ internal static class GuidGenerator
 
         internal static void Reset() => _customId = null;
 
-        private static Guid Create() => Guid.CreateVersion7(InternalClock.UtcNow);
+        private static Guid Create() => Guid.CreateVersion7(InternalClock.TimeProvider.GetUtcNow());
     }
 }

tests/EasyWay.Tests/Entities/AddDomainEventToEntity.cs

@@ -19,7 +19,7 @@ public void AddDomainEvent()
 
             // Assert
             Assert.Equal(1, entity.DomainEvents.Count);
-            Assert.Equal(domainEvent, entity.DomainEvents.Single());
+            Assert.Equal(domainEvent, entity.DomainEvents.Single().DomainEvent);
         }
 
         [Fact(DisplayName = $"When {nameof(DomainEvent)}s are added and then {nameof(Entity.ClearDomainEvents)} is executed, the domain event list should be empty")]