diff --git a/Directory.Packages.props b/Directory.Packages.props
index e889fae..6a877df 100644
--- a/Directory.Packages.props
+++ b/Directory.Packages.props
@@ -18,6 +18,8 @@
+
+
@@ -41,6 +43,8 @@
+
+
diff --git a/TaskFlow.slnx b/TaskFlow.slnx
index 32b160c..9d484db 100644
--- a/TaskFlow.slnx
+++ b/TaskFlow.slnx
@@ -4,6 +4,7 @@
+
@@ -18,8 +19,15 @@
+
+
+
+
+
+
+
diff --git a/dotnet-tools.json b/dotnet-tools.json
new file mode 100644
index 0000000..5c1165b
--- /dev/null
+++ b/dotnet-tools.json
@@ -0,0 +1,13 @@
+{
+ "version": 1,
+ "isRoot": true,
+ "tools": {
+ "dotnet-ef": {
+ "version": "10.0.12",
+ "commands": [
+ "dotnet-ef"
+ ],
+ "rollForward": false
+ }
+ }
+}
\ No newline at end of file
diff --git a/src/AppHost/TaskFlow.AppHost/AppHost.cs b/src/AppHost/TaskFlow.AppHost/AppHost.cs
index 30bad8f..7cd3afb 100644
--- a/src/AppHost/TaskFlow.AppHost/AppHost.cs
+++ b/src/AppHost/TaskFlow.AppHost/AppHost.cs
@@ -8,6 +8,7 @@
// Une base par service : aucun service ne lit la base d'un autre.
var projectsDb = postgres.AddDatabase("projectsdb");
+var tasksDb = postgres.AddDatabase("tasksdb");
// Broker de messages. Le plugin "management" ajoute l'interface web (files, débits, messages en attente).
var rabbitmq = builder.AddRabbitMQ("rabbitmq")
@@ -24,11 +25,21 @@
.WaitFor(rabbitmq)
.WithHttpHealthCheck("/health");
+// Tasks écoute les événements de Projects via RabbitMQ : aucune référence directe entre les deux services.
+var tasksApi = builder.AddProject("tasks-api")
+ .WithReference(tasksDb)
+ .WithReference(rabbitmq)
+ .WaitFor(tasksDb)
+ .WaitFor(rabbitmq)
+ .WithHttpHealthCheck("/health");
+
// ── Gateway : seul point d'entrée du front ──
var gateway = builder.AddProject("gateway")
.WithReference(projectsApi)
+ .WithReference(tasksApi)
.WaitFor(projectsApi)
+ .WaitFor(tasksApi)
.WithHttpHealthCheck("/health");
// ── Front Angular : ne connaît que la Gateway ──
diff --git a/src/AppHost/TaskFlow.AppHost/TaskFlow.AppHost.csproj b/src/AppHost/TaskFlow.AppHost/TaskFlow.AppHost.csproj
index 9151bcf..bab6f80 100644
--- a/src/AppHost/TaskFlow.AppHost/TaskFlow.AppHost.csproj
+++ b/src/AppHost/TaskFlow.AppHost/TaskFlow.AppHost.csproj
@@ -15,6 +15,7 @@
+
diff --git a/src/Services/Projects/TaskFlow.Projects.Api/Infrastructure/GlobalExceptionHandler.cs b/src/BuildingBlocks/TaskFlow.Api.Common/GlobalExceptionHandler.cs
similarity index 64%
rename from src/Services/Projects/TaskFlow.Projects.Api/Infrastructure/GlobalExceptionHandler.cs
rename to src/BuildingBlocks/TaskFlow.Api.Common/GlobalExceptionHandler.cs
index 2d2d17f..8a3ccc2 100644
--- a/src/Services/Projects/TaskFlow.Projects.Api/Infrastructure/GlobalExceptionHandler.cs
+++ b/src/BuildingBlocks/TaskFlow.Api.Common/GlobalExceptionHandler.cs
@@ -1,17 +1,30 @@
using Microsoft.AspNetCore.Diagnostics;
+using Microsoft.AspNetCore.Http;
+using Microsoft.Extensions.Logging;
-namespace TaskFlow.Projects.Api.Infrastructure;
+namespace TaskFlow.Api.Common;
///
/// Filet de sécurité pour les exceptions non prévues : log complet côté serveur,
/// réponse 500 générique côté client (aucun détail technique exposé).
///
-internal sealed partial class GlobalExceptionHandler(
+public sealed partial class GlobalExceptionHandler(
IProblemDetailsService problemDetailsService,
ILogger logger) : IExceptionHandler
{
public async ValueTask TryHandleAsync(HttpContext httpContext, Exception exception, CancellationToken cancellationToken)
{
+ // Requête mal formée (JSON invalide, corps illisible...) : c'est une erreur du CLIENT -> 400, pas 500.
+ if (exception is BadHttpRequestException badRequest)
+ {
+ httpContext.Response.StatusCode = badRequest.StatusCode;
+ return await problemDetailsService.TryWriteAsync(new ProblemDetailsContext
+ {
+ HttpContext = httpContext,
+ ProblemDetails = { Title = "Requête invalide.", Status = badRequest.StatusCode },
+ });
+ }
+
LogUnhandledException(logger, httpContext.Request.Path, exception);
httpContext.Response.StatusCode = StatusCodes.Status500InternalServerError;
diff --git a/src/Services/Projects/TaskFlow.Projects.Api/Infrastructure/ResultExtensions.cs b/src/BuildingBlocks/TaskFlow.Api.Common/ResultExtensions.cs
similarity index 94%
rename from src/Services/Projects/TaskFlow.Projects.Api/Infrastructure/ResultExtensions.cs
rename to src/BuildingBlocks/TaskFlow.Api.Common/ResultExtensions.cs
index b672245..cc367d6 100644
--- a/src/Services/Projects/TaskFlow.Projects.Api/Infrastructure/ResultExtensions.cs
+++ b/src/BuildingBlocks/TaskFlow.Api.Common/ResultExtensions.cs
@@ -1,6 +1,7 @@
+using Microsoft.AspNetCore.Http;
using TaskFlow.SharedKernel;
-namespace TaskFlow.Projects.Api.Infrastructure;
+namespace TaskFlow.Api.Common;
///
/// Traduit un en échec vers une réponse HTTP ProblemDetails.
diff --git a/src/BuildingBlocks/TaskFlow.Api.Common/TaskFlow.Api.Common.csproj b/src/BuildingBlocks/TaskFlow.Api.Common/TaskFlow.Api.Common.csproj
new file mode 100644
index 0000000..d8518d0
--- /dev/null
+++ b/src/BuildingBlocks/TaskFlow.Api.Common/TaskFlow.Api.Common.csproj
@@ -0,0 +1,13 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/src/BuildingBlocks/TaskFlow.Api.Common/ValidationExtensions.cs b/src/BuildingBlocks/TaskFlow.Api.Common/ValidationExtensions.cs
new file mode 100644
index 0000000..9eaa534
--- /dev/null
+++ b/src/BuildingBlocks/TaskFlow.Api.Common/ValidationExtensions.cs
@@ -0,0 +1,17 @@
+using FluentValidation;
+using Microsoft.AspNetCore.Http;
+
+namespace TaskFlow.Api.Common;
+
+public static class ValidationExtensions
+{
+ ///
+ /// Valide une requête avec son validator FluentValidation.
+ /// Renvoie null si elle est valide, sinon une réponse 400 ValidationProblem listant les erreurs par champ.
+ ///
+ public static async Task ValidateRequestAsync(this IValidator validator, T request, CancellationToken ct)
+ {
+ var result = await validator.ValidateAsync(request, ct);
+ return result.IsValid ? null : TypedResults.ValidationProblem(result.ToDictionary());
+ }
+}
diff --git a/src/Gateway/TaskFlow.Gateway/appsettings.json b/src/Gateway/TaskFlow.Gateway/appsettings.json
index d640cc5..7952be6 100644
--- a/src/Gateway/TaskFlow.Gateway/appsettings.json
+++ b/src/Gateway/TaskFlow.Gateway/appsettings.json
@@ -12,6 +12,14 @@
"projects": {
"ClusterId": "projects",
"Match": { "Path": "/api/projects/{**catch-all}" }
+ },
+ "projects-root": {
+ "ClusterId": "projects",
+ "Match": { "Path": "/api/projects" }
+ },
+ "tasks": {
+ "ClusterId": "tasks",
+ "Match": { "Path": "/api/tasks/{**catch-all}" }
}
},
"Clusters": {
@@ -19,6 +27,11 @@
"Destinations": {
"projects-api": { "Address": "https+http://projects-api" }
}
+ },
+ "tasks": {
+ "Destinations": {
+ "tasks-api": { "Address": "https+http://tasks-api" }
+ }
}
}
}
diff --git a/src/Services/Projects/TaskFlow.Projects.Api/Program.cs b/src/Services/Projects/TaskFlow.Projects.Api/Program.cs
index 0fdfcd2..1f5100b 100644
--- a/src/Services/Projects/TaskFlow.Projects.Api/Program.cs
+++ b/src/Services/Projects/TaskFlow.Projects.Api/Program.cs
@@ -1,16 +1,34 @@
using Scalar.AspNetCore;
+using TaskFlow.Api.Common;
using TaskFlow.Projects.Api.Infrastructure;
+using TaskFlow.Projects.Contracts;
using TaskFlow.Projects.Infrastructure;
+using Wolverine;
+using Wolverine.RabbitMQ;
var builder = WebApplication.CreateBuilder(args);
// Aspire : OpenTelemetry, health checks, service discovery, résilience HTTP.
builder.AddServiceDefaults();
-// Connexion RabbitMQ injectée par l'AppHost : ajoute health check et traces.
-// (À l'étape 2, Wolverine utilisera cette même connexion pour publier les événements.)
+// Client RabbitMQ Aspire : health check "RabbitMQ" visible dans /health.
builder.AddRabbitMQClient("rabbitmq");
+// Wolverine : bus de messages. Ce service PUBLIE, il n'écoute aucune queue pour l'instant.
+builder.Host.UseWolverine(opts =>
+{
+ var rabbitMq = builder.Configuration.GetConnectionString("rabbitmq")
+ ?? throw new InvalidOperationException("Chaîne de connexion 'rabbitmq' absente : lancer via l'AppHost Aspire.");
+
+ opts.UseRabbitMq(new Uri(rabbitMq))
+ // Crée les exchanges/queues déclarés s'ils n'existent pas encore.
+ .AutoProvision()
+ // Fanout : chaque service abonné reçoit sa propre copie de l'événement.
+ .DeclareExchange(ProjectsExchanges.ProjectCreated, exchange => exchange.ExchangeType = ExchangeType.Fanout);
+
+ opts.PublishMessage().ToRabbitExchange(ProjectsExchanges.ProjectCreated);
+});
+
// Erreurs au format standard ProblemDetails (RFC 9457).
builder.Services.AddProblemDetails();
builder.Services.AddExceptionHandler();
@@ -21,6 +39,11 @@
var app = builder.Build();
+if (app.Environment.IsDevelopment())
+{
+ await app.Services.MigrateProjectsDatabaseAsync();
+}
+
app.UseExceptionHandler();
app.UseStatusCodePages();
@@ -36,4 +59,4 @@
app.MapInfoEndpoint();
app.MapProjectsModule();
-app.Run();
+await app.RunAsync();
diff --git a/src/Services/Projects/TaskFlow.Projects.Api/TaskFlow.Projects.Api.csproj b/src/Services/Projects/TaskFlow.Projects.Api/TaskFlow.Projects.Api.csproj
index 7c4dddc..04ddd87 100644
--- a/src/Services/Projects/TaskFlow.Projects.Api/TaskFlow.Projects.Api.csproj
+++ b/src/Services/Projects/TaskFlow.Projects.Api/TaskFlow.Projects.Api.csproj
@@ -3,15 +3,14 @@
-
- all
- runtime; build; native; contentfiles; analyzers; buildtransitive
-
+
+
+
diff --git a/src/Services/Projects/TaskFlow.Projects.Application/Abstractions/IProjectRepository.cs b/src/Services/Projects/TaskFlow.Projects.Application/Abstractions/IProjectRepository.cs
new file mode 100644
index 0000000..db42f29
--- /dev/null
+++ b/src/Services/Projects/TaskFlow.Projects.Application/Abstractions/IProjectRepository.cs
@@ -0,0 +1,16 @@
+using TaskFlow.Projects.Domain;
+
+namespace TaskFlow.Projects.Application.Abstractions;
+
+///
+/// Port de persistance défini par l'Application, implémenté par l'Infrastructure (EF Core).
+/// L'Application ne connaît donc ni EF Core ni Postgres.
+///
+public interface IProjectRepository
+{
+ void Add(Project project);
+
+ Task> ListAsync(CancellationToken ct);
+
+ Task SaveChangesAsync(CancellationToken ct);
+}
diff --git a/src/Services/Projects/TaskFlow.Projects.Application/DependencyInjection.cs b/src/Services/Projects/TaskFlow.Projects.Application/DependencyInjection.cs
index 4c6bea9..30f88d8 100644
--- a/src/Services/Projects/TaskFlow.Projects.Application/DependencyInjection.cs
+++ b/src/Services/Projects/TaskFlow.Projects.Application/DependencyInjection.cs
@@ -1,5 +1,6 @@
using FluentValidation;
using Microsoft.Extensions.DependencyInjection;
+using TaskFlow.Projects.Application.Features;
namespace TaskFlow.Projects.Application;
@@ -10,8 +11,9 @@ public static IServiceCollection AddProjectsApplication(this IServiceCollection
// Enregistre automatiquement tous les AbstractValidator du module.
services.AddValidatorsFromAssembly(typeof(DependencyInjection).Assembly, includeInternalTypes: true);
- // TODO (toi) : enregistrer ici les handlers de tes features, ex.
- // services.AddScoped();
+ // Un handler par feature qui modifie l'état.
+ services.AddScoped();
+
return services;
}
}
diff --git a/src/Services/Projects/TaskFlow.Projects.Application/Features/CreateProject.cs b/src/Services/Projects/TaskFlow.Projects.Application/Features/CreateProject.cs
new file mode 100644
index 0000000..2515536
--- /dev/null
+++ b/src/Services/Projects/TaskFlow.Projects.Application/Features/CreateProject.cs
@@ -0,0 +1,71 @@
+using FluentValidation;
+using Microsoft.AspNetCore.Builder;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Routing;
+using TaskFlow.Api.Common;
+using TaskFlow.Projects.Application.Abstractions;
+using TaskFlow.Projects.Contracts;
+using TaskFlow.Projects.Domain;
+using TaskFlow.SharedKernel;
+using Wolverine;
+
+namespace TaskFlow.Projects.Application.Features;
+
+///
+/// Vertical slice « créer un projet » : requête, validation, traitement et endpoint au même endroit.
+/// POST /api/projects { "name": "Refonte du site" }
+///
+public static class CreateProject
+{
+ public sealed record Command(string Name);
+
+ public sealed record Response(Guid Id, string Name, DateTimeOffset CreatedAt);
+
+ /// Validation de FORME (champ présent, longueur). Les règles MÉTIER restent dans l'agrégat.
+ public sealed class Validator : AbstractValidator
+ {
+ public Validator()
+ {
+ RuleFor(c => c.Name).NotEmpty().MaximumLength(Project.NameMaxLength);
+ }
+ }
+
+ public sealed class Handler(IProjectRepository projects, IMessageBus bus, TimeProvider clock)
+ {
+ public async Task> Handle(Command command, CancellationToken ct)
+ {
+ var created = Project.Create(command.Name, clock.GetUtcNow());
+ if (created.IsFailure)
+ {
+ return created.Error;
+ }
+
+ var project = created.Value;
+ projects.Add(project);
+ await projects.SaveChangesAsync(ct);
+
+ // Informe les autres services (Tasks créera le board du projet).
+ // ⚠ Sans outbox, un crash entre SaveChanges et PublishAsync perdrait l'événement :
+ // c'est exactement ce que l'étape 3 corrige (outbox Wolverine, même transaction).
+ await bus.PublishAsync(new ProjectCreated(project.Id.Value, project.Name, project.CreatedAt));
+
+ return new Response(project.Id.Value, project.Name, project.CreatedAt);
+ }
+ }
+
+ public static void Map(RouteGroupBuilder group) =>
+ group.MapPost("/", async Task (Command command, IValidator validator, Handler handler, CancellationToken ct) =>
+ {
+ if (await validator.ValidateRequestAsync(command, ct) is { } invalid)
+ {
+ return invalid;
+ }
+
+ var result = await handler.Handle(command, ct);
+ return result.IsSuccess
+ ? TypedResults.Created($"/api/projects/{result.Value.Id}", result.Value)
+ : result.ToProblem();
+ })
+ .WithName("CreateProject")
+ .WithSummary("Crée un projet et publie l'événement ProjectCreated sur RabbitMQ.");
+}
diff --git a/src/Services/Projects/TaskFlow.Projects.Application/Features/GetProjects.cs b/src/Services/Projects/TaskFlow.Projects.Application/Features/GetProjects.cs
new file mode 100644
index 0000000..7f2a621
--- /dev/null
+++ b/src/Services/Projects/TaskFlow.Projects.Application/Features/GetProjects.cs
@@ -0,0 +1,20 @@
+using Microsoft.AspNetCore.Builder;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Routing;
+using TaskFlow.Projects.Application.Abstractions;
+
+namespace TaskFlow.Projects.Application.Features;
+
+/// GET /api/projects : liste des projets (du plus récent au plus ancien).
+public static class GetProjects
+{
+ public sealed record Item(Guid Id, string Name, DateTimeOffset CreatedAt);
+
+ public static void Map(RouteGroupBuilder group) =>
+ group.MapGet("/", async (IProjectRepository projects, CancellationToken ct) =>
+ {
+ var list = await projects.ListAsync(ct);
+ return TypedResults.Ok(list.Select(p => new Item(p.Id.Value, p.Name, p.CreatedAt)).ToList());
+ })
+ .WithName("GetProjects");
+}
diff --git a/src/Services/Projects/TaskFlow.Projects.Application/ProjectsEndpoints.cs b/src/Services/Projects/TaskFlow.Projects.Application/ProjectsEndpoints.cs
index f5c50e7..9fd83f9 100644
--- a/src/Services/Projects/TaskFlow.Projects.Application/ProjectsEndpoints.cs
+++ b/src/Services/Projects/TaskFlow.Projects.Application/ProjectsEndpoints.cs
@@ -1,20 +1,20 @@
using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Routing;
+using TaskFlow.Projects.Application.Features;
namespace TaskFlow.Projects.Application;
public static class ProjectsEndpoints
{
- /// Point d'entrée HTTP du module : toutes les routes vivent sous /api/projects.
+ /// Point d'entrée HTTP du service : toutes les routes vivent sous /api/projects.
public static IEndpointRouteBuilder MapProjectsEndpoints(this IEndpointRouteBuilder app)
{
var group = app.MapGroup("/api/projects").WithTags("Projects");
- // TODO (toi) : une ligne par feature, ex.
- // CreateProject.Endpoint.Map(group);
- // GetProjects.Endpoint.Map(group);
- _ = group;
+ // Une ligne par feature.
+ CreateProject.Map(group);
+ GetProjects.Map(group);
return app;
}
diff --git a/src/Services/Projects/TaskFlow.Projects.Application/TaskFlow.Projects.Application.csproj b/src/Services/Projects/TaskFlow.Projects.Application/TaskFlow.Projects.Application.csproj
index d861872..22e1f1a 100644
--- a/src/Services/Projects/TaskFlow.Projects.Application/TaskFlow.Projects.Application.csproj
+++ b/src/Services/Projects/TaskFlow.Projects.Application/TaskFlow.Projects.Application.csproj
@@ -1,12 +1,16 @@
-
+
+
+
+
+
diff --git a/src/Services/Projects/TaskFlow.Projects.Contracts/Messaging.cs b/src/Services/Projects/TaskFlow.Projects.Contracts/Messaging.cs
new file mode 100644
index 0000000..2d30752
--- /dev/null
+++ b/src/Services/Projects/TaskFlow.Projects.Contracts/Messaging.cs
@@ -0,0 +1,10 @@
+namespace TaskFlow.Projects.Contracts;
+
+///
+/// Noms des exchanges RabbitMQ sur lesquels le service Projects publie.
+/// Un exchange "fanout" par type d'événement : chaque service abonné y lie SA propre queue.
+///
+public static class ProjectsExchanges
+{
+ public const string ProjectCreated = "projects.project-created";
+}
diff --git a/src/Services/Projects/TaskFlow.Projects.Contracts/ProjectCreated.cs b/src/Services/Projects/TaskFlow.Projects.Contracts/ProjectCreated.cs
new file mode 100644
index 0000000..9df41a8
--- /dev/null
+++ b/src/Services/Projects/TaskFlow.Projects.Contracts/ProjectCreated.cs
@@ -0,0 +1,10 @@
+namespace TaskFlow.Projects.Contracts;
+
+///
+/// Événement d'intégration publié sur RabbitMQ quand un projet est créé.
+/// Contrat public : types simples uniquement, et on n'enlève ni ne renomme jamais un champ.
+///
+/// Identifiant du projet (le même dans tous les services).
+/// Nom du projet au moment de sa création.
+/// Date de création, en UTC.
+public sealed record ProjectCreated(Guid ProjectId, string Name, DateTimeOffset CreatedAt);
diff --git a/src/Services/Projects/TaskFlow.Projects.Domain/Project.cs b/src/Services/Projects/TaskFlow.Projects.Domain/Project.cs
new file mode 100644
index 0000000..eef52e1
--- /dev/null
+++ b/src/Services/Projects/TaskFlow.Projects.Domain/Project.cs
@@ -0,0 +1,46 @@
+using TaskFlow.SharedKernel;
+
+namespace TaskFlow.Projects.Domain;
+
+///
+/// Agrégat Projet. Toutes les règles métier vivent ici : les propriétés ne sont modifiables
+/// que par des méthodes qui vérifient les invariants (pas de setter public).
+///
+public sealed class Project : AggregateRoot
+{
+ public const int NameMaxLength = 100;
+
+ private Project(ProjectId id, string name, DateTimeOffset createdAt) : base(id)
+ {
+ Name = name;
+ CreatedAt = createdAt;
+ }
+
+ // Requis par EF Core.
+ private Project() { }
+
+ public string Name { get; private set; } = string.Empty;
+ public DateTimeOffset CreatedAt { get; private init; }
+
+ ///
+ /// Fabrique : seul moyen de créer un projet valide. Renvoie une erreur métier au lieu de lever une exception.
+ ///
+ public static Result Create(string name, DateTimeOffset now)
+ {
+ var trimmed = name?.Trim() ?? string.Empty;
+
+ if (trimmed.Length == 0)
+ {
+ return ProjectErrors.NameRequired;
+ }
+
+ if (trimmed.Length > NameMaxLength)
+ {
+ return ProjectErrors.NameTooLong;
+ }
+
+ var project = new Project(ProjectId.New(), trimmed, now);
+ project.Raise(new ProjectCreatedDomainEvent(project.Id, project.Name));
+ return project;
+ }
+}
diff --git a/src/Services/Projects/TaskFlow.Projects.Domain/ProjectCreatedDomainEvent.cs b/src/Services/Projects/TaskFlow.Projects.Domain/ProjectCreatedDomainEvent.cs
new file mode 100644
index 0000000..d94f1a9
--- /dev/null
+++ b/src/Services/Projects/TaskFlow.Projects.Domain/ProjectCreatedDomainEvent.cs
@@ -0,0 +1,10 @@
+using TaskFlow.SharedKernel;
+
+namespace TaskFlow.Projects.Domain;
+
+///
+/// Événement de DOMAINE : interne au service, porte des types du domaine (ProjectId).
+/// À ne pas confondre avec l'événement d'INTÉGRATION TaskFlow.Projects.Contracts.ProjectCreated,
+/// public et sérialisé sur RabbitMQ.
+///
+public sealed record ProjectCreatedDomainEvent(ProjectId ProjectId, string Name) : DomainEvent;
diff --git a/src/Services/Projects/TaskFlow.Projects.Domain/ProjectErrors.cs b/src/Services/Projects/TaskFlow.Projects.Domain/ProjectErrors.cs
new file mode 100644
index 0000000..50c8953
--- /dev/null
+++ b/src/Services/Projects/TaskFlow.Projects.Domain/ProjectErrors.cs
@@ -0,0 +1,13 @@
+using TaskFlow.SharedKernel;
+
+namespace TaskFlow.Projects.Domain;
+
+/// Erreurs métier du projet, avec un code stable que le front peut interpréter.
+public static class ProjectErrors
+{
+ public static readonly Error NameRequired =
+ Error.Validation("Project.NameRequired", "Le nom du projet est obligatoire.");
+
+ public static readonly Error NameTooLong =
+ Error.Validation("Project.NameTooLong", $"Le nom du projet ne peut pas dépasser {Project.NameMaxLength} caractères.");
+}
diff --git a/src/Services/Projects/TaskFlow.Projects.Domain/ProjectId.cs b/src/Services/Projects/TaskFlow.Projects.Domain/ProjectId.cs
new file mode 100644
index 0000000..7692d0d
--- /dev/null
+++ b/src/Services/Projects/TaskFlow.Projects.Domain/ProjectId.cs
@@ -0,0 +1,12 @@
+namespace TaskFlow.Projects.Domain;
+
+///
+/// Identifiant fortement typé : impossible de passer un TaskId là où on attend un ProjectId.
+/// Guid v7 : triable par date de création, donc efficace comme clé d'index.
+///
+public readonly record struct ProjectId(Guid Value)
+{
+ public static ProjectId New() => new(Guid.CreateVersion7());
+
+ public override string ToString() => Value.ToString();
+}
diff --git a/src/Services/Projects/TaskFlow.Projects.Infrastructure/Persistence/DesignTimeDbContextFactory.cs b/src/Services/Projects/TaskFlow.Projects.Infrastructure/Persistence/DesignTimeDbContextFactory.cs
new file mode 100644
index 0000000..0458a24
--- /dev/null
+++ b/src/Services/Projects/TaskFlow.Projects.Infrastructure/Persistence/DesignTimeDbContextFactory.cs
@@ -0,0 +1,20 @@
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Design;
+
+namespace TaskFlow.Projects.Infrastructure.Persistence;
+
+///
+/// Utilisé UNIQUEMENT par "dotnet ef migrations add" : fournit un DbContext sans démarrer l'API
+/// (dont la chaîne de connexion n'existe que lorsqu'Aspire la lance). Aucune connexion n'est ouverte.
+///
+internal sealed class DesignTimeDbContextFactory : IDesignTimeDbContextFactory
+{
+ public ProjectsDbContext CreateDbContext(string[] args)
+ {
+ var options = new DbContextOptionsBuilder()
+ .UseNpgsql("Host=localhost;Database=projectsdb")
+ .Options;
+
+ return new ProjectsDbContext(options);
+ }
+}
diff --git a/src/Services/Projects/TaskFlow.Projects.Infrastructure/Persistence/Migrations/20260929141945_InitialCreate.Designer.cs b/src/Services/Projects/TaskFlow.Projects.Infrastructure/Persistence/Migrations/20260929141945_InitialCreate.Designer.cs
new file mode 100644
index 0000000..7f437c3
--- /dev/null
+++ b/src/Services/Projects/TaskFlow.Projects.Infrastructure/Persistence/Migrations/20260929141945_InitialCreate.Designer.cs
@@ -0,0 +1,49 @@
+//
+using System;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+using TaskFlow.Projects.Infrastructure.Persistence;
+
+#nullable disable
+
+namespace TaskFlow.Projects.Infrastructure.Persistence.Migrations
+{
+ [DbContext(typeof(ProjectsDbContext))]
+ [Migration("20260929141945_InitialCreate")]
+ partial class InitialCreate
+ {
+ ///
+ protected override void BuildTargetModel(ModelBuilder modelBuilder)
+ {
+#pragma warning disable 612, 618
+ modelBuilder
+ .HasDefaultSchema("projects")
+ .HasAnnotation("ProductVersion", "10.0.12")
+ .HasAnnotation("Relational:MaxIdentifierLength", 63);
+
+ NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
+
+ modelBuilder.Entity("TaskFlow.Projects.Domain.Project", b =>
+ {
+ b.Property("Id")
+ .HasColumnType("uuid");
+
+ b.Property("CreatedAt")
+ .HasColumnType("timestamp with time zone");
+
+ b.Property("Name")
+ .IsRequired()
+ .HasMaxLength(100)
+ .HasColumnType("character varying(100)");
+
+ b.HasKey("Id");
+
+ b.ToTable("projects", "projects");
+ });
+#pragma warning restore 612, 618
+ }
+ }
+}
diff --git a/src/Services/Projects/TaskFlow.Projects.Infrastructure/Persistence/Migrations/20260929141945_InitialCreate.cs b/src/Services/Projects/TaskFlow.Projects.Infrastructure/Persistence/Migrations/20260929141945_InitialCreate.cs
new file mode 100644
index 0000000..12c6bfe
--- /dev/null
+++ b/src/Services/Projects/TaskFlow.Projects.Infrastructure/Persistence/Migrations/20260929141945_InitialCreate.cs
@@ -0,0 +1,40 @@
+using System;
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace TaskFlow.Projects.Infrastructure.Persistence.Migrations
+{
+ ///
+ public partial class InitialCreate : Migration
+ {
+ ///
+ protected override void Up(MigrationBuilder migrationBuilder)
+ {
+ migrationBuilder.EnsureSchema(
+ name: "projects");
+
+ migrationBuilder.CreateTable(
+ name: "projects",
+ schema: "projects",
+ columns: table => new
+ {
+ Id = table.Column(type: "uuid", nullable: false),
+ Name = table.Column(type: "character varying(100)", maxLength: 100, nullable: false),
+ CreatedAt = table.Column(type: "timestamp with time zone", nullable: false)
+ },
+ constraints: table =>
+ {
+ table.PrimaryKey("PK_projects", x => x.Id);
+ });
+ }
+
+ ///
+ protected override void Down(MigrationBuilder migrationBuilder)
+ {
+ migrationBuilder.DropTable(
+ name: "projects",
+ schema: "projects");
+ }
+ }
+}
diff --git a/src/Services/Projects/TaskFlow.Projects.Infrastructure/Persistence/Migrations/ProjectsDbContextModelSnapshot.cs b/src/Services/Projects/TaskFlow.Projects.Infrastructure/Persistence/Migrations/ProjectsDbContextModelSnapshot.cs
new file mode 100644
index 0000000..35c05a7
--- /dev/null
+++ b/src/Services/Projects/TaskFlow.Projects.Infrastructure/Persistence/Migrations/ProjectsDbContextModelSnapshot.cs
@@ -0,0 +1,46 @@
+//
+using System;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+using TaskFlow.Projects.Infrastructure.Persistence;
+
+#nullable disable
+
+namespace TaskFlow.Projects.Infrastructure.Persistence.Migrations
+{
+ [DbContext(typeof(ProjectsDbContext))]
+ partial class ProjectsDbContextModelSnapshot : ModelSnapshot
+ {
+ protected override void BuildModel(ModelBuilder modelBuilder)
+ {
+#pragma warning disable 612, 618
+ modelBuilder
+ .HasDefaultSchema("projects")
+ .HasAnnotation("ProductVersion", "10.0.12")
+ .HasAnnotation("Relational:MaxIdentifierLength", 63);
+
+ NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
+
+ modelBuilder.Entity("TaskFlow.Projects.Domain.Project", b =>
+ {
+ b.Property("Id")
+ .HasColumnType("uuid");
+
+ b.Property("CreatedAt")
+ .HasColumnType("timestamp with time zone");
+
+ b.Property("Name")
+ .IsRequired()
+ .HasMaxLength(100)
+ .HasColumnType("character varying(100)");
+
+ b.HasKey("Id");
+
+ b.ToTable("projects", "projects");
+ });
+#pragma warning restore 612, 618
+ }
+ }
+}
diff --git a/src/Services/Projects/TaskFlow.Projects.Infrastructure/Persistence/ProjectConfiguration.cs b/src/Services/Projects/TaskFlow.Projects.Infrastructure/Persistence/ProjectConfiguration.cs
new file mode 100644
index 0000000..476c190
--- /dev/null
+++ b/src/Services/Projects/TaskFlow.Projects.Infrastructure/Persistence/ProjectConfiguration.cs
@@ -0,0 +1,30 @@
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Metadata.Builders;
+using TaskFlow.Projects.Domain;
+
+namespace TaskFlow.Projects.Infrastructure.Persistence;
+
+/// Mapping EF Core de l'agrégat : le domaine reste libre de tout attribut de persistance.
+internal sealed class ProjectConfiguration : IEntityTypeConfiguration
+{
+ public void Configure(EntityTypeBuilder builder)
+ {
+ builder.ToTable("projects");
+
+ builder.HasKey(p => p.Id);
+
+ // Identifiant typé <-> uuid en base.
+ builder.Property(p => p.Id)
+ .HasConversion(id => id.Value, value => new ProjectId(value))
+ .ValueGeneratedNever();
+
+ builder.Property(p => p.Name)
+ .HasMaxLength(Project.NameMaxLength)
+ .IsRequired();
+
+ builder.Property(p => p.CreatedAt).IsRequired();
+
+ // Les événements de domaine ne sont pas persistés.
+ builder.Ignore(p => p.DomainEvents);
+ }
+}
diff --git a/src/Services/Projects/TaskFlow.Projects.Infrastructure/Persistence/ProjectRepository.cs b/src/Services/Projects/TaskFlow.Projects.Infrastructure/Persistence/ProjectRepository.cs
new file mode 100644
index 0000000..cd8297f
--- /dev/null
+++ b/src/Services/Projects/TaskFlow.Projects.Infrastructure/Persistence/ProjectRepository.cs
@@ -0,0 +1,16 @@
+using Microsoft.EntityFrameworkCore;
+using TaskFlow.Projects.Application.Abstractions;
+using TaskFlow.Projects.Domain;
+
+namespace TaskFlow.Projects.Infrastructure.Persistence;
+
+/// Public pour la même raison que BoardRepository (code généré par Wolverine).
+public sealed class ProjectRepository(ProjectsDbContext db) : IProjectRepository
+{
+ public void Add(Project project) => db.Projects.Add(project);
+
+ public async Task> ListAsync(CancellationToken ct) =>
+ await db.Projects.AsNoTracking().OrderByDescending(p => p.CreatedAt).ToListAsync(ct);
+
+ public Task SaveChangesAsync(CancellationToken ct) => db.SaveChangesAsync(ct);
+}
diff --git a/src/Services/Projects/TaskFlow.Projects.Infrastructure/Persistence/ProjectsDbContext.cs b/src/Services/Projects/TaskFlow.Projects.Infrastructure/Persistence/ProjectsDbContext.cs
index 1db9bbf..cd86e0c 100644
--- a/src/Services/Projects/TaskFlow.Projects.Infrastructure/Persistence/ProjectsDbContext.cs
+++ b/src/Services/Projects/TaskFlow.Projects.Infrastructure/Persistence/ProjectsDbContext.cs
@@ -1,16 +1,17 @@
using Microsoft.EntityFrameworkCore;
+using TaskFlow.Projects.Domain;
namespace TaskFlow.Projects.Infrastructure.Persistence;
///
-/// DbContext propre au module Projects. Il écrit dans son propre schéma Postgres :
-/// aucun autre module ne doit lire ces tables directement.
+/// DbContext propre au service Projects, dans sa propre base (projectsdb) et son propre schéma.
+/// Aucun autre service ne lit ces tables : ils reçoivent les événements à la place.
///
public sealed class ProjectsDbContext(DbContextOptions options) : DbContext(options)
{
public const string Schema = "projects";
- // TODO (toi) : public DbSet Projects => Set();
+ public DbSet Projects => Set();
protected override void OnModelCreating(ModelBuilder modelBuilder)
{
diff --git a/src/Services/Projects/TaskFlow.Projects.Infrastructure/ProjectsModule.cs b/src/Services/Projects/TaskFlow.Projects.Infrastructure/ProjectsModule.cs
index ac027e7..37f41f8 100644
--- a/src/Services/Projects/TaskFlow.Projects.Infrastructure/ProjectsModule.cs
+++ b/src/Services/Projects/TaskFlow.Projects.Infrastructure/ProjectsModule.cs
@@ -1,11 +1,14 @@
using Microsoft.AspNetCore.Routing;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using TaskFlow.Projects.Application;
+using TaskFlow.Projects.Application.Abstractions;
using TaskFlow.Projects.Infrastructure.Persistence;
namespace TaskFlow.Projects.Infrastructure;
-/// Composition du module : l'API n'appelle que ces deux méthodes.
+/// Composition du service : l'API n'appelle que ces méthodes.
public static class ProjectsModule
{
/// Base propre au service Projects, déclarée dans l'AppHost (AddDatabase("projectsdb")).
@@ -19,9 +22,23 @@ public static IHostApplicationBuilder AddProjectsModule(this IHostApplicationBui
// et ajoute retries, health check et traces OpenTelemetry pour EF Core.
builder.AddNpgsqlDbContext(DatabaseName);
+ builder.Services.AddScoped();
+ builder.Services.AddSingleton(TimeProvider.System);
+
return builder;
}
public static IEndpointRouteBuilder MapProjectsModule(this IEndpointRouteBuilder app) =>
app.MapProjectsEndpoints();
+
+ ///
+ /// Applique les migrations EF Core au démarrage. Réservé au DÉVELOPPEMENT :
+ /// en production, les migrations passent par un bundle exécuté par la CI/CD.
+ ///
+ public static async Task MigrateProjectsDatabaseAsync(this IServiceProvider services)
+ {
+ await using var scope = services.CreateAsyncScope();
+ var db = scope.ServiceProvider.GetRequiredService();
+ await db.Database.MigrateAsync();
+ }
}
diff --git a/src/Services/Projects/TaskFlow.Projects.Infrastructure/TaskFlow.Projects.Infrastructure.csproj b/src/Services/Projects/TaskFlow.Projects.Infrastructure/TaskFlow.Projects.Infrastructure.csproj
index c4c854d..bc7167f 100644
--- a/src/Services/Projects/TaskFlow.Projects.Infrastructure/TaskFlow.Projects.Infrastructure.csproj
+++ b/src/Services/Projects/TaskFlow.Projects.Infrastructure/TaskFlow.Projects.Infrastructure.csproj
@@ -3,6 +3,11 @@
+
+
+ all
+ runtime; build; native; contentfiles; analyzers; buildtransitive
+
diff --git a/src/Services/Tasks/TaskFlow.Tasks.Api/InfoEndpoint.cs b/src/Services/Tasks/TaskFlow.Tasks.Api/InfoEndpoint.cs
new file mode 100644
index 0000000..bdb24fc
--- /dev/null
+++ b/src/Services/Tasks/TaskFlow.Tasks.Api/InfoEndpoint.cs
@@ -0,0 +1,22 @@
+using System.Reflection;
+
+namespace TaskFlow.Tasks.Api;
+
+/// Endpoint technique : identité et version du service Tasks (exposé via la Gateway).
+public static class InfoEndpoint
+{
+ public sealed record ServiceInfo(string Name, string Version, string Environment, DateTimeOffset ServerTime);
+
+ public static IEndpointRouteBuilder MapInfoEndpoint(this IEndpointRouteBuilder app)
+ {
+ app.MapGet("/api/tasks/info", (IHostEnvironment env) => TypedResults.Ok(new ServiceInfo(
+ Name: "TaskFlow Tasks",
+ Version: Assembly.GetExecutingAssembly().GetName().Version?.ToString() ?? "0.0.0",
+ Environment: env.EnvironmentName,
+ ServerTime: DateTimeOffset.UtcNow)))
+ .WithName("GetTasksServiceInfo")
+ .WithTags("Info");
+
+ return app;
+ }
+}
diff --git a/src/Services/Tasks/TaskFlow.Tasks.Api/Program.cs b/src/Services/Tasks/TaskFlow.Tasks.Api/Program.cs
new file mode 100644
index 0000000..e3c35a5
--- /dev/null
+++ b/src/Services/Tasks/TaskFlow.Tasks.Api/Program.cs
@@ -0,0 +1,73 @@
+using JasperFx.CodeGeneration.Model;
+using Scalar.AspNetCore;
+using TaskFlow.Api.Common;
+using TaskFlow.Projects.Contracts;
+using TaskFlow.Tasks.Api;
+using TaskFlow.Tasks.Application.IntegrationEvents;
+using TaskFlow.Tasks.Infrastructure;
+using Wolverine;
+using Wolverine.RabbitMQ;
+using Wolverine.RabbitMQ.Internal;
+
+var builder = WebApplication.CreateBuilder(args);
+
+builder.AddServiceDefaults();
+builder.AddRabbitMQClient("rabbitmq");
+
+// Wolverine : ce service ÉCOUTE les événements des autres services.
+builder.Host.UseWolverine(opts =>
+{
+ var rabbitMq = builder.Configuration.GetConnectionString("rabbitmq")
+ ?? throw new InvalidOperationException("Chaîne de connexion 'rabbitmq' absente : lancer via l'AppHost Aspire.");
+
+ opts.UseRabbitMq(new Uri(rabbitMq))
+ .AutoProvision()
+ // Même exchange que celui déclaré par Projects (la déclaration est idempotente),
+ // auquel on lie la queue PROPRE à Tasks : chaque service abonné a sa copie du message.
+ .DeclareExchange(ProjectsExchanges.ProjectCreated, exchange =>
+ {
+ exchange.ExchangeType = ExchangeType.Fanout;
+ exchange.BindQueue(TasksQueues.ProjectCreated);
+ });
+
+ // Quorum queue : durable et répliquée, le type recommandé depuis RabbitMQ 4.
+ opts.ListenToRabbitQueue(TasksQueues.ProjectCreated, queue => queue.QueueType = QueueType.quorum);
+
+ // Les handlers vivent dans la couche Application, pas dans l'API.
+ opts.Discovery.IncludeAssembly(typeof(ProjectCreatedHandler).Assembly);
+
+ // Le DbContext est enregistré par Aspire via un pool (fabrique opaque) : Wolverine doit alors le
+ // demander au conteneur au lieu de l'instancier dans son code généré. Autorisé, avec un avertissement.
+ // (Étape 3 : l'intégration EF Core de Wolverine, installée pour l'outbox, supprimera ce besoin.)
+ opts.ServiceLocationPolicy = ServiceLocationPolicy.AllowedButWarn;
+});
+
+builder.Services.AddProblemDetails();
+builder.Services.AddExceptionHandler();
+builder.Services.AddOpenApi();
+
+builder.AddTasksModule();
+
+var app = builder.Build();
+
+if (app.Environment.IsDevelopment())
+{
+ await app.Services.MigrateTasksDatabaseAsync();
+}
+
+app.UseExceptionHandler();
+app.UseStatusCodePages();
+
+if (app.Environment.IsDevelopment())
+{
+ app.MapOpenApi();
+ app.MapScalarApiReference();
+}
+
+app.UseHttpsRedirection();
+
+app.MapDefaultEndpoints();
+app.MapInfoEndpoint();
+app.MapTasksModule();
+
+await app.RunAsync();
diff --git a/src/Services/Tasks/TaskFlow.Tasks.Api/Properties/launchSettings.json b/src/Services/Tasks/TaskFlow.Tasks.Api/Properties/launchSettings.json
new file mode 100644
index 0000000..299951c
--- /dev/null
+++ b/src/Services/Tasks/TaskFlow.Tasks.Api/Properties/launchSettings.json
@@ -0,0 +1,23 @@
+{
+ "$schema": "https://json.schemastore.org/launchsettings.json",
+ "profiles": {
+ "http": {
+ "commandName": "Project",
+ "dotnetRunMessages": true,
+ "launchBrowser": true,
+ "applicationUrl": "http://localhost:5089",
+ "environmentVariables": {
+ "ASPNETCORE_ENVIRONMENT": "Development"
+ }
+ },
+ "https": {
+ "commandName": "Project",
+ "dotnetRunMessages": true,
+ "launchBrowser": true,
+ "applicationUrl": "https://localhost:7141;http://localhost:5089",
+ "environmentVariables": {
+ "ASPNETCORE_ENVIRONMENT": "Development"
+ }
+ }
+ }
+}
diff --git a/src/Services/Tasks/TaskFlow.Tasks.Api/TaskFlow.Tasks.Api.csproj b/src/Services/Tasks/TaskFlow.Tasks.Api/TaskFlow.Tasks.Api.csproj
new file mode 100644
index 0000000..35fdcfd
--- /dev/null
+++ b/src/Services/Tasks/TaskFlow.Tasks.Api/TaskFlow.Tasks.Api.csproj
@@ -0,0 +1,17 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/src/Services/Tasks/TaskFlow.Tasks.Api/TasksQueues.cs b/src/Services/Tasks/TaskFlow.Tasks.Api/TasksQueues.cs
new file mode 100644
index 0000000..75145ee
--- /dev/null
+++ b/src/Services/Tasks/TaskFlow.Tasks.Api/TasksQueues.cs
@@ -0,0 +1,9 @@
+namespace TaskFlow.Tasks.Api;
+
+///
+/// Queues RabbitMQ propres au service Tasks. Convention : "{service consommateur}.{événement}".
+///
+public static class TasksQueues
+{
+ public const string ProjectCreated = "tasks.project-created";
+}
diff --git a/src/Services/Tasks/TaskFlow.Tasks.Api/appsettings.Development.json b/src/Services/Tasks/TaskFlow.Tasks.Api/appsettings.Development.json
new file mode 100644
index 0000000..0c208ae
--- /dev/null
+++ b/src/Services/Tasks/TaskFlow.Tasks.Api/appsettings.Development.json
@@ -0,0 +1,8 @@
+{
+ "Logging": {
+ "LogLevel": {
+ "Default": "Information",
+ "Microsoft.AspNetCore": "Warning"
+ }
+ }
+}
diff --git a/src/Services/Tasks/TaskFlow.Tasks.Api/appsettings.json b/src/Services/Tasks/TaskFlow.Tasks.Api/appsettings.json
new file mode 100644
index 0000000..10f68b8
--- /dev/null
+++ b/src/Services/Tasks/TaskFlow.Tasks.Api/appsettings.json
@@ -0,0 +1,9 @@
+{
+ "Logging": {
+ "LogLevel": {
+ "Default": "Information",
+ "Microsoft.AspNetCore": "Warning"
+ }
+ },
+ "AllowedHosts": "*"
+}
diff --git a/src/Services/Tasks/TaskFlow.Tasks.Application/Abstractions/IBoardRepository.cs b/src/Services/Tasks/TaskFlow.Tasks.Application/Abstractions/IBoardRepository.cs
new file mode 100644
index 0000000..8cdc98d
--- /dev/null
+++ b/src/Services/Tasks/TaskFlow.Tasks.Application/Abstractions/IBoardRepository.cs
@@ -0,0 +1,15 @@
+using TaskFlow.Tasks.Domain;
+
+namespace TaskFlow.Tasks.Application.Abstractions;
+
+/// Port de persistance des boards, implémenté par l'Infrastructure (EF Core).
+public interface IBoardRepository
+{
+ Task ExistsForProjectAsync(Guid projectId, CancellationToken ct);
+
+ void Add(Board board);
+
+ Task> ListAsync(CancellationToken ct);
+
+ Task SaveChangesAsync(CancellationToken ct);
+}
diff --git a/src/Services/Tasks/TaskFlow.Tasks.Application/DependencyInjection.cs b/src/Services/Tasks/TaskFlow.Tasks.Application/DependencyInjection.cs
new file mode 100644
index 0000000..14145ca
--- /dev/null
+++ b/src/Services/Tasks/TaskFlow.Tasks.Application/DependencyInjection.cs
@@ -0,0 +1,15 @@
+using FluentValidation;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace TaskFlow.Tasks.Application;
+
+public static class DependencyInjection
+{
+ public static IServiceCollection AddTasksApplication(this IServiceCollection services)
+ {
+ services.AddValidatorsFromAssembly(typeof(DependencyInjection).Assembly, includeInternalTypes: true);
+
+ // Les handlers d'événements (ProjectCreatedHandler...) sont découverts et construits par Wolverine.
+ return services;
+ }
+}
diff --git a/src/Services/Tasks/TaskFlow.Tasks.Application/Features/GetBoards.cs b/src/Services/Tasks/TaskFlow.Tasks.Application/Features/GetBoards.cs
new file mode 100644
index 0000000..b6d9b29
--- /dev/null
+++ b/src/Services/Tasks/TaskFlow.Tasks.Application/Features/GetBoards.cs
@@ -0,0 +1,22 @@
+using Microsoft.AspNetCore.Builder;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Routing;
+using TaskFlow.Tasks.Application.Abstractions;
+
+namespace TaskFlow.Tasks.Application.Features;
+
+/// GET /api/tasks/boards : liste des boards (un par projet).
+public static class GetBoards
+{
+ public sealed record Item(Guid Id, Guid ProjectId, string ProjectName, IReadOnlyList Columns, DateTimeOffset CreatedAt);
+
+ public static void Map(RouteGroupBuilder group) =>
+ group.MapGet("/boards", async (IBoardRepository boards, CancellationToken ct) =>
+ {
+ var list = await boards.ListAsync(ct);
+ return TypedResults.Ok(list
+ .Select(b => new Item(b.Id.Value, b.ProjectId, b.ProjectName, b.Columns, b.CreatedAt))
+ .ToList());
+ })
+ .WithName("GetBoards");
+}
diff --git a/src/Services/Tasks/TaskFlow.Tasks.Application/IntegrationEvents/ProjectCreatedHandler.cs b/src/Services/Tasks/TaskFlow.Tasks.Application/IntegrationEvents/ProjectCreatedHandler.cs
new file mode 100644
index 0000000..0f80cd4
--- /dev/null
+++ b/src/Services/Tasks/TaskFlow.Tasks.Application/IntegrationEvents/ProjectCreatedHandler.cs
@@ -0,0 +1,38 @@
+using Microsoft.Extensions.Logging;
+using TaskFlow.Projects.Contracts;
+using TaskFlow.Tasks.Application.Abstractions;
+using TaskFlow.Tasks.Domain;
+
+namespace TaskFlow.Tasks.Application.IntegrationEvents;
+
+///
+/// Réagit à l'événement ProjectCreated publié par le service Projects : crée le board du projet.
+/// Wolverine le découvre par convention (classe "...Handler", méthode "Handle") ; aucune dépendance à Wolverine ici.
+///
+public sealed partial class ProjectCreatedHandler(
+ IBoardRepository boards,
+ TimeProvider clock,
+ ILogger logger)
+{
+ public async Task Handle(ProjectCreated message, CancellationToken ct)
+ {
+ // IDEMPOTENCE : RabbitMQ garantit "au moins une fois", le même message peut arriver deux fois.
+ // Rejouer ce handler ne doit jamais créer un second board.
+ if (await boards.ExistsForProjectAsync(message.ProjectId, ct))
+ {
+ LogAlreadyExists(logger, message.ProjectId);
+ return;
+ }
+
+ boards.Add(Board.CreateForProject(message.ProjectId, message.Name, clock.GetUtcNow()));
+ await boards.SaveChangesAsync(ct);
+
+ LogBoardCreated(logger, message.ProjectId, message.Name);
+ }
+
+ [LoggerMessage(Level = LogLevel.Information, Message = "Board créé pour le projet {ProjectId} ({ProjectName})")]
+ private static partial void LogBoardCreated(ILogger logger, Guid projectId, string projectName);
+
+ [LoggerMessage(Level = LogLevel.Information, Message = "Board déjà existant pour le projet {ProjectId} : message ignoré (idempotence)")]
+ private static partial void LogAlreadyExists(ILogger logger, Guid projectId);
+}
diff --git a/src/Services/Tasks/TaskFlow.Tasks.Application/TaskFlow.Tasks.Application.csproj b/src/Services/Tasks/TaskFlow.Tasks.Application/TaskFlow.Tasks.Application.csproj
new file mode 100644
index 0000000..c8f8516
--- /dev/null
+++ b/src/Services/Tasks/TaskFlow.Tasks.Application/TaskFlow.Tasks.Application.csproj
@@ -0,0 +1,15 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/src/Services/Tasks/TaskFlow.Tasks.Application/TasksEndpoints.cs b/src/Services/Tasks/TaskFlow.Tasks.Application/TasksEndpoints.cs
new file mode 100644
index 0000000..017bb22
--- /dev/null
+++ b/src/Services/Tasks/TaskFlow.Tasks.Application/TasksEndpoints.cs
@@ -0,0 +1,19 @@
+using Microsoft.AspNetCore.Builder;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Routing;
+using TaskFlow.Tasks.Application.Features;
+
+namespace TaskFlow.Tasks.Application;
+
+public static class TasksEndpoints
+{
+ /// Point d'entrée HTTP du service : toutes les routes vivent sous /api/tasks.
+ public static IEndpointRouteBuilder MapTasksEndpoints(this IEndpointRouteBuilder app)
+ {
+ var group = app.MapGroup("/api/tasks").WithTags("Tasks");
+
+ GetBoards.Map(group);
+
+ return app;
+ }
+}
diff --git a/src/Services/Tasks/TaskFlow.Tasks.Domain/Board.cs b/src/Services/Tasks/TaskFlow.Tasks.Domain/Board.cs
new file mode 100644
index 0000000..3dcc13a
--- /dev/null
+++ b/src/Services/Tasks/TaskFlow.Tasks.Domain/Board.cs
@@ -0,0 +1,40 @@
+using TaskFlow.SharedKernel;
+
+namespace TaskFlow.Tasks.Domain;
+
+///
+/// Board Kanban d'un projet. Un projet a exactement un board, créé automatiquement
+/// quand le service Tasks reçoit l'événement ProjectCreated.
+///
+public sealed class Board : AggregateRoot
+{
+ public static readonly IReadOnlyList DefaultColumns = ["À faire", "En cours", "Terminé"];
+
+ private readonly List _columns = [];
+
+ private Board(BoardId id, Guid projectId, string projectName, DateTimeOffset createdAt) : base(id)
+ {
+ ProjectId = projectId;
+ ProjectName = projectName;
+ CreatedAt = createdAt;
+ _columns.AddRange(DefaultColumns);
+ }
+
+ // Requis par EF Core.
+ private Board() { }
+
+ ///
+ /// Référence au projet d'un AUTRE service : un simple Guid, jamais un objet du domaine Projects.
+ ///
+ public Guid ProjectId { get; private init; }
+
+ /// Copie locale du nom du projet (cohérence éventuelle : mise à jour par événement).
+ public string ProjectName { get; private set; } = string.Empty;
+
+ public DateTimeOffset CreatedAt { get; private init; }
+
+ public IReadOnlyList Columns => _columns.AsReadOnly();
+
+ public static Board CreateForProject(Guid projectId, string projectName, DateTimeOffset now) =>
+ new(BoardId.New(), projectId, projectName, now);
+}
diff --git a/src/Services/Tasks/TaskFlow.Tasks.Domain/BoardId.cs b/src/Services/Tasks/TaskFlow.Tasks.Domain/BoardId.cs
new file mode 100644
index 0000000..9bf37d7
--- /dev/null
+++ b/src/Services/Tasks/TaskFlow.Tasks.Domain/BoardId.cs
@@ -0,0 +1,9 @@
+namespace TaskFlow.Tasks.Domain;
+
+/// Identifiant fortement typé du board (Guid v7).
+public readonly record struct BoardId(Guid Value)
+{
+ public static BoardId New() => new(Guid.CreateVersion7());
+
+ public override string ToString() => Value.ToString();
+}
diff --git a/src/Services/Tasks/TaskFlow.Tasks.Domain/TaskFlow.Tasks.Domain.csproj b/src/Services/Tasks/TaskFlow.Tasks.Domain/TaskFlow.Tasks.Domain.csproj
new file mode 100644
index 0000000..0f551c3
--- /dev/null
+++ b/src/Services/Tasks/TaskFlow.Tasks.Domain/TaskFlow.Tasks.Domain.csproj
@@ -0,0 +1,8 @@
+
+
+
+
+
+
+
+
diff --git a/src/Services/Tasks/TaskFlow.Tasks.Infrastructure/Persistence/BoardConfiguration.cs b/src/Services/Tasks/TaskFlow.Tasks.Infrastructure/Persistence/BoardConfiguration.cs
new file mode 100644
index 0000000..3c3c8fe
--- /dev/null
+++ b/src/Services/Tasks/TaskFlow.Tasks.Infrastructure/Persistence/BoardConfiguration.cs
@@ -0,0 +1,33 @@
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Metadata.Builders;
+using TaskFlow.Tasks.Domain;
+
+namespace TaskFlow.Tasks.Infrastructure.Persistence;
+
+internal sealed class BoardConfiguration : IEntityTypeConfiguration
+{
+ public void Configure(EntityTypeBuilder builder)
+ {
+ builder.ToTable("boards");
+
+ builder.HasKey(b => b.Id);
+
+ builder.Property(b => b.Id)
+ .HasConversion(id => id.Value, value => new BoardId(value))
+ .ValueGeneratedNever();
+
+ // Un seul board par projet : l'index unique est la seconde barrière de l'idempotence
+ // (si deux messages identiques étaient traités en parallèle).
+ builder.HasIndex(b => b.ProjectId).IsUnique();
+
+ builder.Property(b => b.ProjectName).HasMaxLength(100).IsRequired();
+ builder.Property(b => b.CreatedAt).IsRequired();
+
+ // Liste de colonnes stockée en JSON (primitive collection EF Core), via le champ privé _columns.
+ builder.PrimitiveCollection(b => b.Columns)
+ .HasField("_columns")
+ .UsePropertyAccessMode(PropertyAccessMode.Field);
+
+ builder.Ignore(b => b.DomainEvents);
+ }
+}
diff --git a/src/Services/Tasks/TaskFlow.Tasks.Infrastructure/Persistence/BoardRepository.cs b/src/Services/Tasks/TaskFlow.Tasks.Infrastructure/Persistence/BoardRepository.cs
new file mode 100644
index 0000000..8c2c0df
--- /dev/null
+++ b/src/Services/Tasks/TaskFlow.Tasks.Infrastructure/Persistence/BoardRepository.cs
@@ -0,0 +1,23 @@
+using Microsoft.EntityFrameworkCore;
+using TaskFlow.Tasks.Application.Abstractions;
+using TaskFlow.Tasks.Domain;
+
+namespace TaskFlow.Tasks.Infrastructure.Persistence;
+
+///
+/// Public (et non internal) : le code que Wolverine génère pour ses handlers instancie directement
+/// les dépendances. Avec un type internal, il devrait passer par le conteneur (service location),
+/// ce que sa politique par défaut interdit : le message partirait en dead-letter queue.
+///
+public sealed class BoardRepository(TasksDbContext db) : IBoardRepository
+{
+ public Task ExistsForProjectAsync(Guid projectId, CancellationToken ct) =>
+ db.Boards.AnyAsync(b => b.ProjectId == projectId, ct);
+
+ public void Add(Board board) => db.Boards.Add(board);
+
+ public async Task> ListAsync(CancellationToken ct) =>
+ await db.Boards.AsNoTracking().OrderByDescending(b => b.CreatedAt).ToListAsync(ct);
+
+ public Task SaveChangesAsync(CancellationToken ct) => db.SaveChangesAsync(ct);
+}
diff --git a/src/Services/Tasks/TaskFlow.Tasks.Infrastructure/Persistence/DesignTimeDbContextFactory.cs b/src/Services/Tasks/TaskFlow.Tasks.Infrastructure/Persistence/DesignTimeDbContextFactory.cs
new file mode 100644
index 0000000..70163f5
--- /dev/null
+++ b/src/Services/Tasks/TaskFlow.Tasks.Infrastructure/Persistence/DesignTimeDbContextFactory.cs
@@ -0,0 +1,17 @@
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Design;
+
+namespace TaskFlow.Tasks.Infrastructure.Persistence;
+
+/// Utilisé UNIQUEMENT par "dotnet ef migrations add" (aucune connexion n'est ouverte).
+internal sealed class DesignTimeDbContextFactory : IDesignTimeDbContextFactory
+{
+ public TasksDbContext CreateDbContext(string[] args)
+ {
+ var options = new DbContextOptionsBuilder()
+ .UseNpgsql("Host=localhost;Database=tasksdb")
+ .Options;
+
+ return new TasksDbContext(options);
+ }
+}
diff --git a/src/Services/Tasks/TaskFlow.Tasks.Infrastructure/Persistence/Migrations/20260929142223_InitialCreate.Designer.cs b/src/Services/Tasks/TaskFlow.Tasks.Infrastructure/Persistence/Migrations/20260929142223_InitialCreate.Designer.cs
new file mode 100644
index 0000000..856844a
--- /dev/null
+++ b/src/Services/Tasks/TaskFlow.Tasks.Infrastructure/Persistence/Migrations/20260929142223_InitialCreate.Designer.cs
@@ -0,0 +1,59 @@
+//
+using System;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+using TaskFlow.Tasks.Infrastructure.Persistence;
+
+#nullable disable
+
+namespace TaskFlow.Tasks.Infrastructure.Persistence.Migrations
+{
+ [DbContext(typeof(TasksDbContext))]
+ [Migration("20260929142223_InitialCreate")]
+ partial class InitialCreate
+ {
+ ///
+ protected override void BuildTargetModel(ModelBuilder modelBuilder)
+ {
+#pragma warning disable 612, 618
+ modelBuilder
+ .HasDefaultSchema("tasks")
+ .HasAnnotation("ProductVersion", "10.0.12")
+ .HasAnnotation("Relational:MaxIdentifierLength", 63);
+
+ NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
+
+ modelBuilder.Entity("TaskFlow.Tasks.Domain.Board", b =>
+ {
+ b.Property("Id")
+ .HasColumnType("uuid");
+
+ b.PrimitiveCollection("Columns")
+ .IsRequired()
+ .HasColumnType("text[]");
+
+ b.Property("CreatedAt")
+ .HasColumnType("timestamp with time zone");
+
+ b.Property("ProjectId")
+ .HasColumnType("uuid");
+
+ b.Property("ProjectName")
+ .IsRequired()
+ .HasMaxLength(100)
+ .HasColumnType("character varying(100)");
+
+ b.HasKey("Id");
+
+ b.HasIndex("ProjectId")
+ .IsUnique();
+
+ b.ToTable("boards", "tasks");
+ });
+#pragma warning restore 612, 618
+ }
+ }
+}
diff --git a/src/Services/Tasks/TaskFlow.Tasks.Infrastructure/Persistence/Migrations/20260929142223_InitialCreate.cs b/src/Services/Tasks/TaskFlow.Tasks.Infrastructure/Persistence/Migrations/20260929142223_InitialCreate.cs
new file mode 100644
index 0000000..6970062
--- /dev/null
+++ b/src/Services/Tasks/TaskFlow.Tasks.Infrastructure/Persistence/Migrations/20260929142223_InitialCreate.cs
@@ -0,0 +1,49 @@
+using System;
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace TaskFlow.Tasks.Infrastructure.Persistence.Migrations
+{
+ ///
+ public partial class InitialCreate : Migration
+ {
+ ///
+ protected override void Up(MigrationBuilder migrationBuilder)
+ {
+ migrationBuilder.EnsureSchema(
+ name: "tasks");
+
+ migrationBuilder.CreateTable(
+ name: "boards",
+ schema: "tasks",
+ columns: table => new
+ {
+ Id = table.Column(type: "uuid", nullable: false),
+ ProjectId = table.Column(type: "uuid", nullable: false),
+ ProjectName = table.Column(type: "character varying(100)", maxLength: 100, nullable: false),
+ CreatedAt = table.Column(type: "timestamp with time zone", nullable: false),
+ Columns = table.Column(type: "text[]", nullable: false)
+ },
+ constraints: table =>
+ {
+ table.PrimaryKey("PK_boards", x => x.Id);
+ });
+
+ migrationBuilder.CreateIndex(
+ name: "IX_boards_ProjectId",
+ schema: "tasks",
+ table: "boards",
+ column: "ProjectId",
+ unique: true);
+ }
+
+ ///
+ protected override void Down(MigrationBuilder migrationBuilder)
+ {
+ migrationBuilder.DropTable(
+ name: "boards",
+ schema: "tasks");
+ }
+ }
+}
diff --git a/src/Services/Tasks/TaskFlow.Tasks.Infrastructure/Persistence/Migrations/TasksDbContextModelSnapshot.cs b/src/Services/Tasks/TaskFlow.Tasks.Infrastructure/Persistence/Migrations/TasksDbContextModelSnapshot.cs
new file mode 100644
index 0000000..8c75026
--- /dev/null
+++ b/src/Services/Tasks/TaskFlow.Tasks.Infrastructure/Persistence/Migrations/TasksDbContextModelSnapshot.cs
@@ -0,0 +1,56 @@
+//
+using System;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+using TaskFlow.Tasks.Infrastructure.Persistence;
+
+#nullable disable
+
+namespace TaskFlow.Tasks.Infrastructure.Persistence.Migrations
+{
+ [DbContext(typeof(TasksDbContext))]
+ partial class TasksDbContextModelSnapshot : ModelSnapshot
+ {
+ protected override void BuildModel(ModelBuilder modelBuilder)
+ {
+#pragma warning disable 612, 618
+ modelBuilder
+ .HasDefaultSchema("tasks")
+ .HasAnnotation("ProductVersion", "10.0.12")
+ .HasAnnotation("Relational:MaxIdentifierLength", 63);
+
+ NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
+
+ modelBuilder.Entity("TaskFlow.Tasks.Domain.Board", b =>
+ {
+ b.Property("Id")
+ .HasColumnType("uuid");
+
+ b.PrimitiveCollection("Columns")
+ .IsRequired()
+ .HasColumnType("text[]");
+
+ b.Property("CreatedAt")
+ .HasColumnType("timestamp with time zone");
+
+ b.Property("ProjectId")
+ .HasColumnType("uuid");
+
+ b.Property("ProjectName")
+ .IsRequired()
+ .HasMaxLength(100)
+ .HasColumnType("character varying(100)");
+
+ b.HasKey("Id");
+
+ b.HasIndex("ProjectId")
+ .IsUnique();
+
+ b.ToTable("boards", "tasks");
+ });
+#pragma warning restore 612, 618
+ }
+ }
+}
diff --git a/src/Services/Tasks/TaskFlow.Tasks.Infrastructure/Persistence/TasksDbContext.cs b/src/Services/Tasks/TaskFlow.Tasks.Infrastructure/Persistence/TasksDbContext.cs
new file mode 100644
index 0000000..60a2e3f
--- /dev/null
+++ b/src/Services/Tasks/TaskFlow.Tasks.Infrastructure/Persistence/TasksDbContext.cs
@@ -0,0 +1,18 @@
+using Microsoft.EntityFrameworkCore;
+using TaskFlow.Tasks.Domain;
+
+namespace TaskFlow.Tasks.Infrastructure.Persistence;
+
+/// DbContext propre au service Tasks, dans sa propre base (tasksdb) et son propre schéma.
+public sealed class TasksDbContext(DbContextOptions options) : DbContext(options)
+{
+ public const string Schema = "tasks";
+
+ public DbSet Boards => Set();
+
+ protected override void OnModelCreating(ModelBuilder modelBuilder)
+ {
+ modelBuilder.HasDefaultSchema(Schema);
+ modelBuilder.ApplyConfigurationsFromAssembly(typeof(TasksDbContext).Assembly);
+ }
+}
diff --git a/src/Services/Tasks/TaskFlow.Tasks.Infrastructure/TaskFlow.Tasks.Infrastructure.csproj b/src/Services/Tasks/TaskFlow.Tasks.Infrastructure/TaskFlow.Tasks.Infrastructure.csproj
new file mode 100644
index 0000000..3f2e19c
--- /dev/null
+++ b/src/Services/Tasks/TaskFlow.Tasks.Infrastructure/TaskFlow.Tasks.Infrastructure.csproj
@@ -0,0 +1,16 @@
+
+
+
+
+
+
+ all
+ runtime; build; native; contentfiles; analyzers; buildtransitive
+
+
+
+
+
+
+
+
diff --git a/src/Services/Tasks/TaskFlow.Tasks.Infrastructure/TasksModule.cs b/src/Services/Tasks/TaskFlow.Tasks.Infrastructure/TasksModule.cs
new file mode 100644
index 0000000..da717c6
--- /dev/null
+++ b/src/Services/Tasks/TaskFlow.Tasks.Infrastructure/TasksModule.cs
@@ -0,0 +1,39 @@
+using Microsoft.AspNetCore.Routing;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Hosting;
+using TaskFlow.Tasks.Application;
+using TaskFlow.Tasks.Application.Abstractions;
+using TaskFlow.Tasks.Infrastructure.Persistence;
+
+namespace TaskFlow.Tasks.Infrastructure;
+
+/// Composition du service Tasks.
+public static class TasksModule
+{
+ /// Base propre au service Tasks, déclarée dans l'AppHost (AddDatabase("tasksdb")).
+ public const string DatabaseName = "tasksdb";
+
+ public static IHostApplicationBuilder AddTasksModule(this IHostApplicationBuilder builder)
+ {
+ builder.Services.AddTasksApplication();
+
+ builder.AddNpgsqlDbContext(DatabaseName);
+
+ builder.Services.AddScoped();
+ builder.Services.AddSingleton(TimeProvider.System);
+
+ return builder;
+ }
+
+ public static IEndpointRouteBuilder MapTasksModule(this IEndpointRouteBuilder app) =>
+ app.MapTasksEndpoints();
+
+ /// Applique les migrations au démarrage (développement uniquement).
+ public static async Task MigrateTasksDatabaseAsync(this IServiceProvider services)
+ {
+ await using var scope = services.CreateAsyncScope();
+ var db = scope.ServiceProvider.GetRequiredService();
+ await db.Database.MigrateAsync();
+ }
+}
diff --git a/tests/TaskFlow.ArchitectureTests/MicroserviceBoundaryTests.cs b/tests/TaskFlow.ArchitectureTests/MicroserviceBoundaryTests.cs
index df36710..d3e7df3 100644
--- a/tests/TaskFlow.ArchitectureTests/MicroserviceBoundaryTests.cs
+++ b/tests/TaskFlow.ArchitectureTests/MicroserviceBoundaryTests.cs
@@ -12,6 +12,12 @@ public class MicroserviceBoundaryTests
private static readonly Assembly Gateway = Assembly.Load("TaskFlow.Gateway");
private static readonly Assembly ProjectsContracts = Assembly.Load("TaskFlow.Projects.Contracts");
+ private static readonly string[] ProjectsAssemblies =
+ ["TaskFlow.Projects.Api", "TaskFlow.Projects.Application", "TaskFlow.Projects.Domain", "TaskFlow.Projects.Infrastructure"];
+
+ private static readonly string[] TasksAssemblies =
+ ["TaskFlow.Tasks.Api", "TaskFlow.Tasks.Application", "TaskFlow.Tasks.Domain", "TaskFlow.Tasks.Infrastructure"];
+
private static IEnumerable TaskFlowReferences(Assembly assembly) =>
assembly.GetReferencedAssemblies()
.Select(a => a.Name!)
@@ -33,4 +39,28 @@ public void Les_Contracts_ne_dependent_d_aucun_autre_projet_TaskFlow()
// Un contrat public doit pouvoir être référencé par n'importe quel service sans rien entraîner.
TaskFlowReferences(ProjectsContracts).ShouldBeEmpty();
}
+
+ [Fact]
+ public void Tasks_ne_connait_de_Projects_que_son_contrat()
+ {
+ foreach (var name in TasksAssemblies)
+ {
+ var forbidden = TaskFlowReferences(Assembly.Load(name))
+ .Where(r => r.StartsWith("TaskFlow.Projects.", StringComparison.Ordinal) && r != "TaskFlow.Projects.Contracts")
+ .ToList();
+
+ forbidden.ShouldBeEmpty($"{name} référence : {string.Join(", ", forbidden)}");
+ }
+ }
+
+ [Fact]
+ public void Projects_ne_connait_pas_Tasks()
+ {
+ foreach (var name in ProjectsAssemblies)
+ {
+ TaskFlowReferences(Assembly.Load(name))
+ .Where(r => r.StartsWith("TaskFlow.Tasks.", StringComparison.Ordinal))
+ .ShouldBeEmpty($"{name} ne doit pas connaître le service Tasks");
+ }
+ }
}
diff --git a/tests/TaskFlow.ArchitectureTests/TaskFlow.ArchitectureTests.csproj b/tests/TaskFlow.ArchitectureTests/TaskFlow.ArchitectureTests.csproj
index 470f029..8d0ab10 100644
--- a/tests/TaskFlow.ArchitectureTests/TaskFlow.ArchitectureTests.csproj
+++ b/tests/TaskFlow.ArchitectureTests/TaskFlow.ArchitectureTests.csproj
@@ -12,6 +12,7 @@
+
diff --git a/tests/TaskFlow.ArchitectureTests/TasksLayerDependencyTests.cs b/tests/TaskFlow.ArchitectureTests/TasksLayerDependencyTests.cs
new file mode 100644
index 0000000..ab97400
--- /dev/null
+++ b/tests/TaskFlow.ArchitectureTests/TasksLayerDependencyTests.cs
@@ -0,0 +1,38 @@
+using System.Reflection;
+using NetArchTest.Rules;
+using Shouldly;
+
+namespace TaskFlow.ArchitectureTests;
+
+/// Même règle de dépendance que pour Projects, appliquée au service Tasks.
+public class TasksLayerDependencyTests
+{
+ private static readonly Assembly TasksDomain = Assembly.Load("TaskFlow.Tasks.Domain");
+ private static readonly Assembly TasksApplication = Assembly.Load("TaskFlow.Tasks.Application");
+
+ [Fact]
+ public void Domain_ne_depend_ni_d_EF_Core_ni_d_ASP_NET_ni_d_un_autre_service()
+ {
+ var result = Types.InAssembly(TasksDomain)
+ .ShouldNot().HaveDependencyOnAny(
+ "Microsoft.EntityFrameworkCore",
+ "Microsoft.AspNetCore",
+ "TaskFlow.Tasks.Application",
+ "TaskFlow.Tasks.Infrastructure",
+ "TaskFlow.Projects")
+ .GetResult();
+
+ result.IsSuccessful.ShouldBeTrue(LayerDependencyTests.Describe(result));
+ }
+
+ [Fact]
+ public void Application_ne_depend_ni_d_EF_Core_ni_de_Wolverine()
+ {
+ // Les handlers d'événements restent de simples classes : Wolverine les découvre par convention.
+ var result = Types.InAssembly(TasksApplication)
+ .ShouldNot().HaveDependencyOnAny("Microsoft.EntityFrameworkCore", "Wolverine", "TaskFlow.Tasks.Infrastructure")
+ .GetResult();
+
+ result.IsSuccessful.ShouldBeTrue(LayerDependencyTests.Describe(result));
+ }
+}
diff --git a/tests/TaskFlow.Projects.UnitTests/ProjectTests.cs b/tests/TaskFlow.Projects.UnitTests/ProjectTests.cs
new file mode 100644
index 0000000..320e3e3
--- /dev/null
+++ b/tests/TaskFlow.Projects.UnitTests/ProjectTests.cs
@@ -0,0 +1,43 @@
+using Shouldly;
+using TaskFlow.Projects.Domain;
+
+namespace TaskFlow.Projects.UnitTests;
+
+public class ProjectTests
+{
+ private static readonly DateTimeOffset Now = new(2026, 9, 29, 12, 0, 0, TimeSpan.Zero);
+
+ [Fact]
+ public void Create_avec_un_nom_valide_cree_le_projet_et_leve_ProjectCreatedDomainEvent()
+ {
+ var result = Project.Create(" Refonte du site ", Now);
+
+ result.IsSuccess.ShouldBeTrue();
+ var project = result.Value;
+ project.Name.ShouldBe("Refonte du site"); // espaces retirés
+ project.CreatedAt.ShouldBe(Now);
+ project.Id.Value.ShouldNotBe(Guid.Empty);
+
+ var domainEvent = project.DomainEvents.ShouldHaveSingleItem().ShouldBeOfType();
+ domainEvent.ProjectId.ShouldBe(project.Id);
+ }
+
+ [Theory]
+ [InlineData("")]
+ [InlineData(" ")]
+ public void Create_sans_nom_echoue_avec_NameRequired(string name)
+ {
+ var result = Project.Create(name, Now);
+
+ result.IsFailure.ShouldBeTrue();
+ result.Error.ShouldBe(ProjectErrors.NameRequired);
+ }
+
+ [Fact]
+ public void Create_avec_un_nom_trop_long_echoue_avec_NameTooLong()
+ {
+ var result = Project.Create(new string('x', Project.NameMaxLength + 1), Now);
+
+ result.Error.ShouldBe(ProjectErrors.NameTooLong);
+ }
+}
diff --git a/tests/TaskFlow.Tasks.UnitTests/ProjectCreatedHandlerTests.cs b/tests/TaskFlow.Tasks.UnitTests/ProjectCreatedHandlerTests.cs
new file mode 100644
index 0000000..de891f3
--- /dev/null
+++ b/tests/TaskFlow.Tasks.UnitTests/ProjectCreatedHandlerTests.cs
@@ -0,0 +1,57 @@
+using Microsoft.Extensions.Logging.Abstractions;
+using Shouldly;
+using TaskFlow.Projects.Contracts;
+using TaskFlow.Tasks.Application.Abstractions;
+using TaskFlow.Tasks.Application.IntegrationEvents;
+using TaskFlow.Tasks.Domain;
+
+namespace TaskFlow.Tasks.UnitTests;
+
+public class ProjectCreatedHandlerTests
+{
+ private readonly InMemoryBoardRepository _boards = new();
+ private readonly ProjectCreatedHandler _handler;
+
+ public ProjectCreatedHandlerTests() =>
+ _handler = new ProjectCreatedHandler(_boards, TimeProvider.System, NullLogger.Instance);
+
+ [Fact]
+ public async Task Cree_le_board_du_projet_avec_les_colonnes_par_defaut()
+ {
+ var message = new ProjectCreated(Guid.NewGuid(), "Refonte du site", DateTimeOffset.UtcNow);
+
+ await _handler.Handle(message, TestContext.Current.CancellationToken);
+
+ var board = _boards.Items.ShouldHaveSingleItem();
+ board.ProjectId.ShouldBe(message.ProjectId);
+ board.ProjectName.ShouldBe("Refonte du site");
+ board.Columns.ShouldBe(Board.DefaultColumns);
+ }
+
+ [Fact]
+ public async Task Est_idempotent_un_message_recu_deux_fois_ne_cree_qu_un_board()
+ {
+ var message = new ProjectCreated(Guid.NewGuid(), "Refonte du site", DateTimeOffset.UtcNow);
+
+ await _handler.Handle(message, TestContext.Current.CancellationToken);
+ await _handler.Handle(message, TestContext.Current.CancellationToken); // redistribution RabbitMQ
+
+ _boards.Items.Count.ShouldBe(1);
+ }
+
+ /// Faux dépôt en mémoire : teste la logique du handler sans base de données.
+ private sealed class InMemoryBoardRepository : IBoardRepository
+ {
+ public List Items { get; } = [];
+
+ public Task ExistsForProjectAsync(Guid projectId, CancellationToken ct) =>
+ Task.FromResult(Items.Any(b => b.ProjectId == projectId));
+
+ public void Add(Board board) => Items.Add(board);
+
+ public Task> ListAsync(CancellationToken ct) =>
+ Task.FromResult>(Items);
+
+ public Task SaveChangesAsync(CancellationToken ct) => Task.CompletedTask;
+ }
+}
diff --git a/tests/TaskFlow.Tasks.UnitTests/TaskFlow.Tasks.UnitTests.csproj b/tests/TaskFlow.Tasks.UnitTests/TaskFlow.Tasks.UnitTests.csproj
new file mode 100644
index 0000000..1d10a64
--- /dev/null
+++ b/tests/TaskFlow.Tasks.UnitTests/TaskFlow.Tasks.UnitTests.csproj
@@ -0,0 +1,19 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+