feat: add domain event (v.1.2.0)

FlowMediator.Console/Entities/TestEntity.cs

@@ -0,0 +1,18 @@
+using FlowMediator.Console.Events;
+using FlowMediator.Contracts;
+
+namespace FlowMediator.Console.Entities
+{
+    public class TestEntity : BaseEntity
+    {
+        public string Name { get; private set; }
+
+        public static TestEntity Create(string name)
+        {
+            var entity = new TestEntity { Name = name };
+            entity.AddDomainEvent(new TestEvent($"Entity {name} created"));
+            return entity;
+        }
+    }
+
+}

FlowMediator.Console/User.cs → FlowMediator.Console/Entities/User.cs

@@ -1,4 +1,4 @@
-namespace FlowMediator.Console
+namespace FlowMediator.Console.Entities
 {
     public class User
     {

FlowMediator.Console/EventHandlers/TestEventHandler.cs

@@ -0,0 +1,15 @@
+using FlowMediator.Console.Events;
+using FlowMediator.Contracts;
+
+namespace FlowMediator.Console.EventHandlers
+{
+    public class TestEventHandler : IRequestHandler<TestEvent, Unit>
+    {
+        public Task<Unit> Handle(TestEvent request, CancellationToken cancellationToken)
+        {
+            System.Console.WriteLine($"[Handler] Event triggered with message: {request.Message}");
+            return Task.FromResult(Unit.Value);
+        }
+    }
+
+}

FlowMediator.Console/Events/TestEvent.cs

@@ -0,0 +1,13 @@
+using FlowMediator.Contracts;
+
+namespace FlowMediator.Console.Events
+{
+    public class TestEvent : IDomainEvent
+    {
+        public string Message { get; }
+        public DateTime OccurredOn { get; } = DateTime.UtcNow;
+
+        public TestEvent(string message) => Message = message;
+    }
+
+}

FlowMediator.Console/Program.cs

@@ -1,58 +1,64 @@
 using FlowMediator.Console;
 using FlowMediator.Console.Behaviors;
+using FlowMediator.Console.Entities;
+using FlowMediator.Console.Queries;
+using FlowMediator.Console.Repositories;
 using FlowMediator.Contracts;
 using FlowMediator.Extensions;
 using FluentValidation;
 using Microsoft.Extensions.DependencyInjection;
 using System.Reflection;
 
 // handlers + behavior pipelines are automatic
-
 //var services = new ServiceCollection();
-
 //services.AddFlowMediatorWithBehaviors(Assembly.GetExecutingAssembly());
-
 //services.AddSingleton<IUserRepository, UserRepository>();
-
 //services.AddValidatorsFromAssembly(Assembly.GetExecutingAssembly());
-
 //var provider = services.BuildServiceProvider();
 //var mediator = provider.GetRequiredService<IMediator>();
 
-
 // handlers are automatic, behavior pipelines manual 
 var services = new ServiceCollection();
 
 services.AddFlowMediator(Assembly.GetExecutingAssembly());
 
 services.AddSingleton<IUserRepository, UserRepository>();
-
 services.AddValidatorsFromAssembly(Assembly.GetExecutingAssembly());
 
-
 services.AddTransient(typeof(IPipelineBehavior<,>), typeof(LoggingBehavior<,>));
 services.AddTransient(typeof(IPipelineBehavior<,>), typeof(ValidationBehavior<,>));
 
 var provider = services.BuildServiceProvider();
 var mediator = provider.GetRequiredService<IMediator>();
 
-
-
+// ------------------------
+// Query test
+// ------------------------
 var user = await mediator.SendAsync(new GetUserByIdQuery(1));
-Console.WriteLine($"User Id: {user.Id}, Name: {user.Name}");
-
+System.Console.WriteLine($"User Id: {user.Id}, Name: {user.Name}");
 
 try
 {
     var invalidUser = await mediator.SendAsync(new GetUserByIdQuery(0));
-    Console.WriteLine($"User Id: {invalidUser.Id}, Name: {invalidUser.Name}");
+    System.Console.WriteLine($"User Id: {invalidUser.Id}, Name: {invalidUser.Name}");
 }
 catch (ValidationException ex)
 {
-    Console.WriteLine("Validation failed:");
+    System.Console.WriteLine("Validation failed:");
     foreach (var error in ex.Errors)
     {
-        Console.WriteLine($"   - {error.PropertyName}: {error.ErrorMessage}");
+        System.Console.WriteLine($"   - {error.PropertyName}: {error.ErrorMessage}");
     }
 }
 
+// ------------------------
+// Domain Event test
+// ------------------------
+var testEntity = TestEntity.Create("SampleEntity");
+
+
+foreach (var domainEvent in testEntity.DomainEvents)
+{
+    await mediator.SendAsync(domainEvent);
+}
+testEntity.ClearDomainEvents();

FlowMediator.Console/GetUserByIdHandler.cs → FlowMediator.Console/Queries/GetUserByIdHandler.cs

@@ -1,6 +1,8 @@
-using FlowMediator.Contracts;
+using FlowMediator.Console.Entities;
+using FlowMediator.Console.Repositories;
+using FlowMediator.Contracts;
 
-namespace FlowMediator.Console
+namespace FlowMediator.Console.Queries
 {
     public class GetUserByIdHandler : IRequestHandler<GetUserByIdQuery, User>
     {

FlowMediator.Console/GetUserByIdQuery.cs → FlowMediator.Console/Queries/GetUserByIdQuery.cs

@@ -1,6 +1,7 @@
-using FlowMediator.Contracts;
+using FlowMediator.Console.Entities;
+using FlowMediator.Contracts;
 
-namespace FlowMediator.Console
+namespace FlowMediator.Console.Queries
 {
     public class GetUserByIdQuery : IRequest<User>
     {

FlowMediator.Console/IUserRepository.cs → FlowMediator.Console/Repositories/IUserRepository.cs

@@ -1,4 +1,6 @@
-namespace FlowMediator.Console
+using FlowMediator.Console.Entities;
+
+namespace FlowMediator.Console.Repositories
 {
     public interface IUserRepository
     {

FlowMediator.Console/Validators/GetUserByIdQueryValidator.cs

@@ -1,4 +1,5 @@
-using FluentValidation;
+using FlowMediator.Console.Queries;
+using FluentValidation;
 
 namespace FlowMediator.Console.Validators
 {

FlowMediator/Contracts/BaseEntity.cs

@@ -0,0 +1,14 @@
+namespace FlowMediator.Contracts
+{
+    /// <summary>
+    /// Base class for domain entities that can raise domain events.
+    /// </summary>
+    public abstract class BaseEntity
+    {
+        private readonly List<IDomainEvent> _domainEvents = new();
+        public IReadOnlyCollection<IDomainEvent> DomainEvents => _domainEvents.AsReadOnly();
+
+        protected void AddDomainEvent(IDomainEvent domainEvent) => _domainEvents.Add(domainEvent);
+        public void ClearDomainEvents() => _domainEvents.Clear();
+    }
+}

FlowMediator/Contracts/IDomainEvent.cs

@@ -0,0 +1,12 @@
+namespace FlowMediator.Contracts
+{
+    /// <summary>
+    /// Marker interface for domain events.
+    /// Domain events are treated as IRequest<Unit> so they flow through mediator like commands.
+    /// </summary>
+    public interface IDomainEvent : IRequest<Unit>
+    {
+        DateTime OccurredOn { get; }
+    }
+}
+

FlowMediator/Contracts/Unit.cs

@@ -0,0 +1,11 @@
+namespace FlowMediator.Contracts
+{
+    /// <summary>
+    /// Represents a void result (like MediatR.Unit).
+    /// </summary>
+    public struct Unit
+    {
+        public static readonly Unit Value = new Unit();
+    }
+}
+

tests/FlowMediator.Tests/DomainEventTests.cs

@@ -0,0 +1,31 @@
+using FlowMediator.Contracts;
+using FlowMediator.Extensions;
+using FlowMediator.Tests.DomainEvents;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace FlowMediator.Tests
+{
+    public class DomainEventTests
+    {
+        [Fact]
+        public async Task Should_Handle_DomainEvent_When_EntityCreated()
+        {
+            // Arrange
+            var services = new ServiceCollection();
+            services.AddFlowMediator(typeof(DomainEventTests).Assembly);
+            var provider = services.BuildServiceProvider();
+            var mediator = provider.GetRequiredService<IMediator>();
+
+            var entity = TestEntity.Create("UnitTest");
+
+            // Act
+            foreach (var domainEvent in entity.DomainEvents)
+            {
+                await mediator.SendAsync(domainEvent);
+            }
+
+            Assert.Single(entity.DomainEvents);
+        }
+    }
+
+}

tests/FlowMediator.Tests/DomainEvents/TestEntity.cs

@@ -0,0 +1,17 @@
+using FlowMediator.Contracts;
+
+namespace FlowMediator.Tests.DomainEvents
+{
+    public class TestEntity : BaseEntity
+    {
+        public string Name { get; private set; }
+
+        public static TestEntity Create(string name)
+        {
+            var entity = new TestEntity { Name = name };
+            entity.AddDomainEvent(new TestEvent($"Entity {name} created"));
+            return entity;
+        }
+    }
+
+}

tests/FlowMediator.Tests/DomainEvents/TestEvent.cs

@@ -0,0 +1,13 @@
+using FlowMediator.Contracts;
+
+namespace FlowMediator.Tests.DomainEvents
+{
+    public class TestEvent : IDomainEvent
+    {
+        public string Message { get; }
+        public DateTime OccurredOn { get; } = DateTime.UtcNow;
+
+        public TestEvent(string message) => Message = message;
+    }
+
+}

tests/FlowMediator.Tests/DomainEvents/TestEventHandler.cs

@@ -0,0 +1,14 @@
+using FlowMediator.Contracts;
+
+namespace FlowMediator.Tests.DomainEvents
+{
+    public class TestEventHandler : IRequestHandler<TestEvent, Unit>
+    {
+        public Task<Unit> Handle(TestEvent request, CancellationToken cancellationToken)
+        {
+            System.Console.WriteLine($"[Handler] Event triggered with message: {request.Message}");
+            return Task.FromResult(Unit.Value);
+        }
+    }
+
+}