From 1b819b6f593a5f834c6adf73cbbbc32fd26d197d Mon Sep 17 00:00:00 2001
From: Carl Marion <carlmarion.develops@gmail.com>
Date: Wed, 27 May 2026 12:27:28 +0800
Subject: [PATCH 01/31] feat(catalog): scaffold five-project module structure

---
 Eternelle.slnx                                | 22 +++++++++++++++++++
 .../AssemblyReference.cs                      |  8 +++++++
 ...ernelle.Modules.Catalog.Application.csproj |  9 ++++++++
 .../Eternelle.Modules.Catalog.Domain.csproj   |  7 ++++++
 .../Database/Schemas.cs                       |  6 +++++
 ...elle.Modules.Catalog.Infrastructure.csproj | 16 ++++++++++++++
 ...e.Modules.Catalog.IntegrationEvents.csproj |  7 ++++++
 .../AssemblyReference.cs                      |  8 +++++++
 ...rnelle.Modules.Catalog.Presentation.csproj |  8 +++++++
 9 files changed, 91 insertions(+)
 create mode 100644 src/Modules/Catalog/Eternelle.Modules.Catalog.Application/AssemblyReference.cs
 create mode 100644 src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Eternelle.Modules.Catalog.Application.csproj
 create mode 100644 src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Eternelle.Modules.Catalog.Domain.csproj
 create mode 100644 src/Modules/Catalog/Eternelle.Modules.Catalog.Infrastructure/Database/Schemas.cs
 create mode 100644 src/Modules/Catalog/Eternelle.Modules.Catalog.Infrastructure/Eternelle.Modules.Catalog.Infrastructure.csproj
 create mode 100644 src/Modules/Catalog/Eternelle.Modules.Catalog.IntegrationEvents/Eternelle.Modules.Catalog.IntegrationEvents.csproj
 create mode 100644 src/Modules/Catalog/Eternelle.Modules.Catalog.Presentation/AssemblyReference.cs
 create mode 100644 src/Modules/Catalog/Eternelle.Modules.Catalog.Presentation/Eternelle.Modules.Catalog.Presentation.csproj

diff --git a/Eternelle.slnx b/Eternelle.slnx
index b2c3b55..933c179 100644
--- a/Eternelle.slnx
+++ b/Eternelle.slnx
@@ -1,4 +1,19 @@
 <Solution>
+  <Folder Name="/docs/">
+    <File Path="docs/feature-gift-contributions.md" />
+    <File Path="docs/feature-guest-photo-upload.md" />
+    <File Path="docs/module-conventions.md" />
+  </Folder>
+  <Folder Name="/docs/superpowers/" />
+  <Folder Name="/docs/superpowers/plans/">
+    <File Path="docs/superpowers/plans/2026-05-20-users-module.md" />
+    <File Path="docs/superpowers/plans/2026-05-24-weddings-inbox-outbox-alignment.md" />
+    <File Path="docs/superpowers/plans/2026-05-27-catalog-module.md" />
+  </Folder>
+  <Folder Name="/docs/superpowers/specs/">
+    <File Path="docs/superpowers/specs/2026-05-20-users-module-design.md" />
+    <File Path="docs/superpowers/specs/2026-05-27-catalog-module-design.md" />
+  </Folder>
   <Folder Name="/Solution Items/">
     <File Path=".editorconfig" />
     <File Path="Directory.Build.props" />
@@ -15,6 +30,13 @@
     <Project Path="src/Common/Eternelle.Common.Presentation/Eternelle.Common.Presentation.csproj" Id="54cfc49d-e0bb-44a0-84ac-ee35515c1b5e" />
   </Folder>
   <Folder Name="/src/Modules/" />
+  <Folder Name="/src/Modules/Catalog/">
+    <Project Path="src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Eternelle.Modules.Catalog.Application.csproj" />
+    <Project Path="src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Eternelle.Modules.Catalog.Domain.csproj" />
+    <Project Path="src/Modules/Catalog/Eternelle.Modules.Catalog.Infrastructure/Eternelle.Modules.Catalog.Infrastructure.csproj" />
+    <Project Path="src/Modules/Catalog/Eternelle.Modules.Catalog.IntegrationEvents/Eternelle.Modules.Catalog.IntegrationEvents.csproj" />
+    <Project Path="src/Modules/Catalog/Eternelle.Modules.Catalog.Presentation/Eternelle.Modules.Catalog.Presentation.csproj" />
+  </Folder>
   <Folder Name="/src/Modules/Users/">
     <Project Path="src/Modules/Users/Eternelle.Modules.Users.Application/Eternelle.Modules.Users.Application.csproj" Id="27530601-1743-4d73-80d3-bddbf28d8eb2" />
     <Project Path="src/Modules/Users/Eternelle.Modules.Users.Domain/Eternelle.Modules.Users.Domain.csproj" Id="823bb7bc-2382-4588-a404-73ae27f49b02" />
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/AssemblyReference.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/AssemblyReference.cs
new file mode 100644
index 0000000..5600467
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/AssemblyReference.cs
@@ -0,0 +1,8 @@
+using System.Reflection;
+
+namespace Eternelle.Modules.Catalog.Application;
+
+public static class AssemblyReference
+{
+    public static readonly Assembly Assembly = typeof(AssemblyReference).Assembly;
+}
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Eternelle.Modules.Catalog.Application.csproj b/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Eternelle.Modules.Catalog.Application.csproj
new file mode 100644
index 0000000..a6c704f
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Eternelle.Modules.Catalog.Application.csproj
@@ -0,0 +1,9 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <ItemGroup>
+    <ProjectReference Include="..\Eternelle.Modules.Catalog.Domain\Eternelle.Modules.Catalog.Domain.csproj" />
+    <ProjectReference Include="..\Eternelle.Modules.Catalog.IntegrationEvents\Eternelle.Modules.Catalog.IntegrationEvents.csproj" />
+    <ProjectReference Include="..\..\..\Common\Eternelle.Common.Application\Eternelle.Common.Application.csproj" />
+  </ItemGroup>
+
+</Project>
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Eternelle.Modules.Catalog.Domain.csproj b/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Eternelle.Modules.Catalog.Domain.csproj
new file mode 100644
index 0000000..06763b3
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Eternelle.Modules.Catalog.Domain.csproj
@@ -0,0 +1,7 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <ItemGroup>
+    <ProjectReference Include="..\..\..\Common\Eternelle.Common.Domain\Eternelle.Common.Domain.csproj" />
+  </ItemGroup>
+
+</Project>
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Infrastructure/Database/Schemas.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Infrastructure/Database/Schemas.cs
new file mode 100644
index 0000000..ee3561e
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Infrastructure/Database/Schemas.cs
@@ -0,0 +1,6 @@
+namespace Eternelle.Modules.Catalog.Infrastructure.Database;
+
+internal static class Schemas
+{
+    internal const string Catalog = "catalog";
+}
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Infrastructure/Eternelle.Modules.Catalog.Infrastructure.csproj b/src/Modules/Catalog/Eternelle.Modules.Catalog.Infrastructure/Eternelle.Modules.Catalog.Infrastructure.csproj
new file mode 100644
index 0000000..6e1754e
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Infrastructure/Eternelle.Modules.Catalog.Infrastructure.csproj
@@ -0,0 +1,16 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <ItemGroup>
+    <ProjectReference Include="..\Eternelle.Modules.Catalog.Application\Eternelle.Modules.Catalog.Application.csproj" />
+    <ProjectReference Include="..\Eternelle.Modules.Catalog.Presentation\Eternelle.Modules.Catalog.Presentation.csproj" />
+    <ProjectReference Include="..\..\..\Common\Eternelle.Common.Infrastructure\Eternelle.Common.Infrastructure.csproj" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.EntityFrameworkCore.Design">
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+      <PrivateAssets>all</PrivateAssets>
+    </PackageReference>
+  </ItemGroup>
+
+</Project>
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.IntegrationEvents/Eternelle.Modules.Catalog.IntegrationEvents.csproj b/src/Modules/Catalog/Eternelle.Modules.Catalog.IntegrationEvents/Eternelle.Modules.Catalog.IntegrationEvents.csproj
new file mode 100644
index 0000000..b9e5a29
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.IntegrationEvents/Eternelle.Modules.Catalog.IntegrationEvents.csproj
@@ -0,0 +1,7 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <ItemGroup>
+    <ProjectReference Include="..\..\..\Common\Eternelle.Common.Application\Eternelle.Common.Application.csproj" />
+  </ItemGroup>
+
+</Project>
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Presentation/AssemblyReference.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Presentation/AssemblyReference.cs
new file mode 100644
index 0000000..711bf77
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Presentation/AssemblyReference.cs
@@ -0,0 +1,8 @@
+using System.Reflection;
+
+namespace Eternelle.Modules.Catalog.Presentation;
+
+public static class AssemblyReference
+{
+    public static readonly Assembly Assembly = typeof(AssemblyReference).Assembly;
+}
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Presentation/Eternelle.Modules.Catalog.Presentation.csproj b/src/Modules/Catalog/Eternelle.Modules.Catalog.Presentation/Eternelle.Modules.Catalog.Presentation.csproj
new file mode 100644
index 0000000..297b70e
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Presentation/Eternelle.Modules.Catalog.Presentation.csproj
@@ -0,0 +1,8 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <ItemGroup>
+    <ProjectReference Include="..\Eternelle.Modules.Catalog.Application\Eternelle.Modules.Catalog.Application.csproj" />
+    <ProjectReference Include="..\..\..\Common\Eternelle.Common.Presentation\Eternelle.Common.Presentation.csproj" />
+  </ItemGroup>
+
+</Project>

From 75139b7f873938bbfb6609450d3125897158dedb Mon Sep 17 00:00:00 2001
From: Carl Marion <carlmarion.develops@gmail.com>
Date: Wed, 27 May 2026 12:43:49 +0800
Subject: [PATCH 02/31] feat(catalog): add TemplateTier, PriceClass, SectionId
 enums

---
 .../Templates/PriceClass.cs                   |  8 ++++++++
 .../Templates/SectionId.cs                    | 20 +++++++++++++++++++
 .../Templates/TemplateTier.cs                 |  7 +++++++
 3 files changed, 35 insertions(+)
 create mode 100644 src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/PriceClass.cs
 create mode 100644 src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/SectionId.cs
 create mode 100644 src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/TemplateTier.cs

diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/PriceClass.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/PriceClass.cs
new file mode 100644
index 0000000..21ef21e
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/PriceClass.cs
@@ -0,0 +1,8 @@
+namespace Eternelle.Modules.Catalog.Domain.Templates;
+
+public enum PriceClass
+{
+    Free = 1,
+    Pro = 2,
+    Plus = 3
+}
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/SectionId.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/SectionId.cs
new file mode 100644
index 0000000..d87cdaa
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/SectionId.cs
@@ -0,0 +1,20 @@
+namespace Eternelle.Modules.Catalog.Domain.Templates;
+
+// Persisted as the enum NAME (string) so the Tenancy module can match selections
+// against this catalog by a stable identifier. Do not renumber/rename without a migration.
+public enum SectionId
+{
+    Hero,
+    Story,
+    Entourage,
+    DressCode,
+    Gallery,
+    GiftGuide,
+    Guestbook,
+    Venue,
+    Reminders,
+    Rsvp,
+    VendorCredits,
+    SnapShare,
+    GuestUploads
+}
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/TemplateTier.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/TemplateTier.cs
new file mode 100644
index 0000000..1c94a31
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/TemplateTier.cs
@@ -0,0 +1,7 @@
+namespace Eternelle.Modules.Catalog.Domain.Templates;
+
+public enum TemplateTier
+{
+    FirstClass = 1,
+    Signature = 2
+}

From ab649c539670a632fb93ff0e94e0ccf19f4b8298 Mon Sep 17 00:00:00 2001
From: Carl Marion <carlmarion.develops@gmail.com>
Date: Wed, 27 May 2026 13:02:47 +0800
Subject: [PATCH 03/31] feat(catalog): add strongly-typed ids for Template and
 children

---
 .../Templates/TemplateId.cs                                | 7 +++++++
 .../Templates/TemplateSectionVariantId.cs                  | 7 +++++++
 .../Templates/TemplateSupportedSectionId.cs                | 7 +++++++
 .../Templates/TemplateThemeId.cs                           | 7 +++++++
 4 files changed, 28 insertions(+)
 create mode 100644 src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/TemplateId.cs
 create mode 100644 src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/TemplateSectionVariantId.cs
 create mode 100644 src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/TemplateSupportedSectionId.cs
 create mode 100644 src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/TemplateThemeId.cs

diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/TemplateId.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/TemplateId.cs
new file mode 100644
index 0000000..619eb4c
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/TemplateId.cs
@@ -0,0 +1,7 @@
+namespace Eternelle.Modules.Catalog.Domain.Templates;
+
+public readonly record struct TemplateId(Guid Value)
+{
+    public static TemplateId New() => new(Guid.CreateVersion7());
+    public override string ToString() => Value.ToString();
+}
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/TemplateSectionVariantId.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/TemplateSectionVariantId.cs
new file mode 100644
index 0000000..c585487
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/TemplateSectionVariantId.cs
@@ -0,0 +1,7 @@
+namespace Eternelle.Modules.Catalog.Domain.Templates;
+
+public readonly record struct TemplateSectionVariantId(Guid Value)
+{
+    public static TemplateSectionVariantId New() => new(Guid.CreateVersion7());
+    public override string ToString() => Value.ToString();
+}
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/TemplateSupportedSectionId.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/TemplateSupportedSectionId.cs
new file mode 100644
index 0000000..0f50248
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/TemplateSupportedSectionId.cs
@@ -0,0 +1,7 @@
+namespace Eternelle.Modules.Catalog.Domain.Templates;
+
+public readonly record struct TemplateSupportedSectionId(Guid Value)
+{
+    public static TemplateSupportedSectionId New() => new(Guid.CreateVersion7());
+    public override string ToString() => Value.ToString();
+}
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/TemplateThemeId.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/TemplateThemeId.cs
new file mode 100644
index 0000000..d0c1508
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/TemplateThemeId.cs
@@ -0,0 +1,7 @@
+namespace Eternelle.Modules.Catalog.Domain.Templates;
+
+public readonly record struct TemplateThemeId(Guid Value)
+{
+    public static TemplateThemeId New() => new(Guid.CreateVersion7());
+    public override string ToString() => Value.ToString();
+}

From e88b1bdfd48a4e51abe275cb54e5853e59d879a4 Mon Sep 17 00:00:00 2001
From: Carl Marion <carlmarion.develops@gmail.com>
Date: Wed, 27 May 2026 13:04:19 +0800
Subject: [PATCH 04/31] feat(catalog): add value objects and errors

---
 .../Shared/ImageUrl.cs                        | 38 +++++++++++++++++++
 .../Shared/ImageUrlErrors.cs                  | 15 ++++++++
 .../Templates/TemplateDescription.cs          | 33 ++++++++++++++++
 .../Templates/TemplateDescriptionErrors.cs    | 12 ++++++
 .../Templates/TemplateName.cs                 | 33 ++++++++++++++++
 .../Templates/TemplateNameErrors.cs           | 12 ++++++
 .../Templates/TemplateThemeName.cs            | 33 ++++++++++++++++
 .../Templates/TemplateThemeNameErrors.cs      | 12 ++++++
 8 files changed, 188 insertions(+)
 create mode 100644 src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Shared/ImageUrl.cs
 create mode 100644 src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Shared/ImageUrlErrors.cs
 create mode 100644 src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/TemplateDescription.cs
 create mode 100644 src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/TemplateDescriptionErrors.cs
 create mode 100644 src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/TemplateName.cs
 create mode 100644 src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/TemplateNameErrors.cs
 create mode 100644 src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/TemplateThemeName.cs
 create mode 100644 src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/TemplateThemeNameErrors.cs

diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Shared/ImageUrl.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Shared/ImageUrl.cs
new file mode 100644
index 0000000..917e306
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Shared/ImageUrl.cs
@@ -0,0 +1,38 @@
+using Eternelle.Common.Domain;
+
+namespace Eternelle.Modules.Catalog.Domain.Shared;
+
+public sealed record ImageUrl
+{
+    public const int MaxLength = 2048;
+
+    private ImageUrl(string value) => Value = value;
+
+    public string Value { get; }
+
+    public static Result<ImageUrl> Create(string? raw)
+    {
+        if (string.IsNullOrWhiteSpace(raw))
+        {
+            return Result.Failure<ImageUrl>(ImageUrlErrors.Empty);
+        }
+
+        string trimmed = raw.Trim();
+
+        if (trimmed.Length > MaxLength)
+        {
+            return Result.Failure<ImageUrl>(ImageUrlErrors.TooLong);
+        }
+
+        if (!Uri.TryCreate(trimmed, UriKind.RelativeOrAbsolute, out _))
+        {
+            return Result.Failure<ImageUrl>(ImageUrlErrors.InvalidFormat);
+        }
+
+        return Result.Success(new ImageUrl(trimmed));
+    }
+
+    public override string ToString() => Value;
+
+    internal static ImageUrl FromPersistence(string value) => new(value);
+}
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Shared/ImageUrlErrors.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Shared/ImageUrlErrors.cs
new file mode 100644
index 0000000..df5ecce
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Shared/ImageUrlErrors.cs
@@ -0,0 +1,15 @@
+using Eternelle.Common.Domain;
+
+namespace Eternelle.Modules.Catalog.Domain.Shared;
+
+internal static class ImageUrlErrors
+{
+    public static readonly Error Empty =
+        Error.Problem("ImageUrl.Empty", "Image URL must not be empty");
+
+    public static readonly Error TooLong =
+        Error.Problem("ImageUrl.TooLong", $"Image URL must not exceed {ImageUrl.MaxLength} characters");
+
+    public static readonly Error InvalidFormat =
+        Error.Problem("ImageUrl.InvalidFormat", "Image URL must be a valid URI");
+}
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/TemplateDescription.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/TemplateDescription.cs
new file mode 100644
index 0000000..0956f2e
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/TemplateDescription.cs
@@ -0,0 +1,33 @@
+using Eternelle.Common.Domain;
+
+namespace Eternelle.Modules.Catalog.Domain.Templates;
+
+public sealed record TemplateDescription
+{
+    public const int MaxLength = 1000;
+
+    private TemplateDescription(string value) => Value = value;
+
+    public string Value { get; }
+
+    public static Result<TemplateDescription> Create(string? raw)
+    {
+        if (string.IsNullOrWhiteSpace(raw))
+        {
+            return Result.Failure<TemplateDescription>(TemplateDescriptionErrors.Empty);
+        }
+
+        string trimmed = raw.Trim();
+
+        if (trimmed.Length > MaxLength)
+        {
+            return Result.Failure<TemplateDescription>(TemplateDescriptionErrors.TooLong);
+        }
+
+        return Result.Success(new TemplateDescription(trimmed));
+    }
+
+    public override string ToString() => Value;
+
+    internal static TemplateDescription FromPersistence(string value) => new(value);
+}
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/TemplateDescriptionErrors.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/TemplateDescriptionErrors.cs
new file mode 100644
index 0000000..f10497f
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/TemplateDescriptionErrors.cs
@@ -0,0 +1,12 @@
+using Eternelle.Common.Domain;
+
+namespace Eternelle.Modules.Catalog.Domain.Templates;
+
+internal static class TemplateDescriptionErrors
+{
+    public static readonly Error Empty =
+        Error.Problem("TemplateDescription.Empty", "Template description must not be empty when provided");
+
+    public static readonly Error TooLong =
+        Error.Problem("TemplateDescription.TooLong", $"Template description must not exceed {TemplateDescription.MaxLength} characters");
+}
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/TemplateName.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/TemplateName.cs
new file mode 100644
index 0000000..7f7a9c6
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/TemplateName.cs
@@ -0,0 +1,33 @@
+using Eternelle.Common.Domain;
+
+namespace Eternelle.Modules.Catalog.Domain.Templates;
+
+public sealed record TemplateName
+{
+    public const int MaxLength = 150;
+
+    private TemplateName(string value) => Value = value;
+
+    public string Value { get; }
+
+    public static Result<TemplateName> Create(string? raw)
+    {
+        if (string.IsNullOrWhiteSpace(raw))
+        {
+            return Result.Failure<TemplateName>(TemplateNameErrors.Empty);
+        }
+
+        string trimmed = raw.Trim();
+
+        if (trimmed.Length > MaxLength)
+        {
+            return Result.Failure<TemplateName>(TemplateNameErrors.TooLong);
+        }
+
+        return Result.Success(new TemplateName(trimmed));
+    }
+
+    public override string ToString() => Value;
+
+    internal static TemplateName FromPersistence(string value) => new(value);
+}
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/TemplateNameErrors.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/TemplateNameErrors.cs
new file mode 100644
index 0000000..cd2ef8b
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/TemplateNameErrors.cs
@@ -0,0 +1,12 @@
+using Eternelle.Common.Domain;
+
+namespace Eternelle.Modules.Catalog.Domain.Templates;
+
+internal static class TemplateNameErrors
+{
+    public static readonly Error Empty =
+        Error.Problem("TemplateName.Empty", "Template name must not be empty");
+
+    public static readonly Error TooLong =
+        Error.Problem("TemplateName.TooLong", $"Template name must not exceed {TemplateName.MaxLength} characters");
+}
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/TemplateThemeName.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/TemplateThemeName.cs
new file mode 100644
index 0000000..6a14a29
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/TemplateThemeName.cs
@@ -0,0 +1,33 @@
+using Eternelle.Common.Domain;
+
+namespace Eternelle.Modules.Catalog.Domain.Templates;
+
+public sealed record TemplateThemeName
+{
+    public const int MaxLength = 100;
+
+    private TemplateThemeName(string value) => Value = value;
+
+    public string Value { get; }
+
+    public static Result<TemplateThemeName> Create(string? raw)
+    {
+        if (string.IsNullOrWhiteSpace(raw))
+        {
+            return Result.Failure<TemplateThemeName>(TemplateThemeNameErrors.Empty);
+        }
+
+        string trimmed = raw.Trim();
+
+        if (trimmed.Length > MaxLength)
+        {
+            return Result.Failure<TemplateThemeName>(TemplateThemeNameErrors.TooLong);
+        }
+
+        return Result.Success(new TemplateThemeName(trimmed));
+    }
+
+    public override string ToString() => Value;
+
+    internal static TemplateThemeName FromPersistence(string value) => new(value);
+}
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/TemplateThemeNameErrors.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/TemplateThemeNameErrors.cs
new file mode 100644
index 0000000..2fcf177
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/TemplateThemeNameErrors.cs
@@ -0,0 +1,12 @@
+using Eternelle.Common.Domain;
+
+namespace Eternelle.Modules.Catalog.Domain.Templates;
+
+internal static class TemplateThemeNameErrors
+{
+    public static readonly Error Empty =
+        Error.Problem("TemplateThemeName.Empty", "Theme name must not be empty");
+
+    public static readonly Error TooLong =
+        Error.Problem("TemplateThemeName.TooLong", $"Theme name must not exceed {TemplateThemeName.MaxLength} characters");
+}

From e159b63b6aa774e209e1e2a504be2d0fde7f8e84 Mon Sep 17 00:00:00 2001
From: Carl Marion <carlmarion.develops@gmail.com>
Date: Wed, 27 May 2026 13:05:18 +0800
Subject: [PATCH 05/31] feat(catalog): add jsonb theme styling records

---
 .../Templates/ThemeStyling.cs                            | 9 +++++++++
 1 file changed, 9 insertions(+)
 create mode 100644 src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/ThemeStyling.cs

diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/ThemeStyling.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/ThemeStyling.cs
new file mode 100644
index 0000000..5301c1f
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/ThemeStyling.cs
@@ -0,0 +1,9 @@
+namespace Eternelle.Modules.Catalog.Domain.Templates;
+
+// Serialized to jsonb columns. Dictionaries keep the schema open for design tokens
+// (e.g. { "primary": "#1a1a1a", "accent": "#c8a96a" }) without a migration per token.
+public sealed record ThemeColors(IReadOnlyDictionary<string, string> Tokens);
+
+public sealed record ThemeTypography(IReadOnlyDictionary<string, string> Tokens);
+
+public sealed record ThemeTextures(IReadOnlyDictionary<string, string> Tokens);

From 5567a653858678d20c66b2496297dbf4816ace35 Mon Sep 17 00:00:00 2001
From: Carl Marion <carlmarion.develops@gmail.com>
Date: Wed, 27 May 2026 13:06:15 +0800
Subject: [PATCH 06/31] feat(catalog): add Template child entities with variant
 upload limit

---
 .../Templates/TemplateSectionVariant.cs       | 36 ++++++++++++++++++
 .../Templates/TemplateSupportedSection.cs     | 25 +++++++++++++
 .../Templates/TemplateTheme.cs                | 37 +++++++++++++++++++
 3 files changed, 98 insertions(+)
 create mode 100644 src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/TemplateSectionVariant.cs
 create mode 100644 src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/TemplateSupportedSection.cs
 create mode 100644 src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/TemplateTheme.cs

diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/TemplateSectionVariant.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/TemplateSectionVariant.cs
new file mode 100644
index 0000000..0f719e7
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/TemplateSectionVariant.cs
@@ -0,0 +1,36 @@
+using Eternelle.Common.Domain;
+
+namespace Eternelle.Modules.Catalog.Domain.Templates;
+
+public sealed class TemplateSectionVariant : Entity
+{
+    private TemplateSectionVariant() { }
+
+    public TemplateSectionVariantId Id { get; private set; }
+    public TemplateId TemplateId { get; private set; }
+    public SectionId SectionId { get; private set; }
+    public string Variant { get; private set; } = null!;
+    public bool IsDefault { get; private set; }
+    public PriceClass PriceClass { get; private set; }
+
+    // Upload cap for upload-capable sections (e.g. GuestUploads). null = unlimited / N/A.
+    public int? UploadLimit { get; private set; }
+
+    internal static TemplateSectionVariant Create(
+        TemplateId templateId,
+        SectionId sectionId,
+        string variant,
+        bool isDefault,
+        PriceClass priceClass,
+        int? uploadLimit) =>
+        new()
+        {
+            Id = TemplateSectionVariantId.New(),
+            TemplateId = templateId,
+            SectionId = sectionId,
+            Variant = variant,
+            IsDefault = isDefault,
+            PriceClass = priceClass,
+            UploadLimit = uploadLimit
+        };
+}
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/TemplateSupportedSection.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/TemplateSupportedSection.cs
new file mode 100644
index 0000000..d63c398
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/TemplateSupportedSection.cs
@@ -0,0 +1,25 @@
+using Eternelle.Common.Domain;
+
+namespace Eternelle.Modules.Catalog.Domain.Templates;
+
+public sealed class TemplateSupportedSection : Entity
+{
+    private TemplateSupportedSection() { }
+
+    public TemplateSupportedSectionId Id { get; private set; }
+    public TemplateId TemplateId { get; private set; }
+    public SectionId SectionId { get; private set; }
+    public int DisplayOrder { get; private set; }
+
+    internal static TemplateSupportedSection Create(
+        TemplateId templateId,
+        SectionId sectionId,
+        int displayOrder) =>
+        new()
+        {
+            Id = TemplateSupportedSectionId.New(),
+            TemplateId = templateId,
+            SectionId = sectionId,
+            DisplayOrder = displayOrder
+        };
+}
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/TemplateTheme.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/TemplateTheme.cs
new file mode 100644
index 0000000..15c66df
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/TemplateTheme.cs
@@ -0,0 +1,37 @@
+using Eternelle.Common.Domain;
+
+namespace Eternelle.Modules.Catalog.Domain.Templates;
+
+public sealed class TemplateTheme : Entity
+{
+    private TemplateTheme() { }
+
+    public TemplateThemeId Id { get; private set; }
+    public TemplateId TemplateId { get; private set; }
+    public int ThemeIndex { get; private set; }
+    public TemplateThemeName Name { get; private set; } = null!;
+    public ThemeColors Colors { get; private set; } = null!;
+    public ThemeTypography Typography { get; private set; } = null!;
+    public ThemeTextures? Textures { get; private set; }
+    public bool IsDark { get; private set; }
+
+    internal static TemplateTheme Create(
+        TemplateId templateId,
+        int themeIndex,
+        TemplateThemeName name,
+        ThemeColors colors,
+        ThemeTypography typography,
+        ThemeTextures? textures,
+        bool isDark) =>
+        new()
+        {
+            Id = TemplateThemeId.New(),
+            TemplateId = templateId,
+            ThemeIndex = themeIndex,
+            Name = name,
+            Colors = colors,
+            Typography = typography,
+            Textures = textures,
+            IsDark = isDark
+        };
+}

From d503809e03a13ad7edcdfc48a37f9a2ba9642599 Mon Sep 17 00:00:00 2001
From: Carl Marion <carlmarion.develops@gmail.com>
Date: Wed, 27 May 2026 13:09:31 +0800
Subject: [PATCH 07/31] feat(catalog): add Template domain events and manifest
 payload

---
 .../Templates/TemplateCreatedDomainEvent.cs     | 13 +++++++++++++
 .../TemplateManifestChangedDomainEvent.cs       | 17 +++++++++++++++++
 .../Templates/TemplateManifestItem.cs           |  8 ++++++++
 3 files changed, 38 insertions(+)
 create mode 100644 src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/TemplateCreatedDomainEvent.cs
 create mode 100644 src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/TemplateManifestChangedDomainEvent.cs
 create mode 100644 src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/TemplateManifestItem.cs

diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/TemplateCreatedDomainEvent.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/TemplateCreatedDomainEvent.cs
new file mode 100644
index 0000000..f42b3e9
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/TemplateCreatedDomainEvent.cs
@@ -0,0 +1,13 @@
+using Eternelle.Common.Domain;
+
+namespace Eternelle.Modules.Catalog.Domain.Templates;
+
+public sealed class TemplateCreatedDomainEvent(
+    TemplateId templateId,
+    string name,
+    string tier) : DomainEvent
+{
+    public TemplateId TemplateId { get; init; } = templateId;
+    public string Name { get; init; } = name;
+    public string Tier { get; init; } = tier;
+}
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/TemplateManifestChangedDomainEvent.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/TemplateManifestChangedDomainEvent.cs
new file mode 100644
index 0000000..9e5d4fc
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/TemplateManifestChangedDomainEvent.cs
@@ -0,0 +1,17 @@
+using Eternelle.Common.Domain;
+
+namespace Eternelle.Modules.Catalog.Domain.Templates;
+
+public sealed class TemplateManifestChangedDomainEvent(
+    TemplateId templateId,
+    string name,
+    string tier,
+    IReadOnlyList<string> sectionIds,
+    IReadOnlyList<TemplateManifestItem> variants) : DomainEvent
+{
+    public TemplateId TemplateId { get; init; } = templateId;
+    public string Name { get; init; } = name;
+    public string Tier { get; init; } = tier;
+    public IReadOnlyList<string> SectionIds { get; init; } = sectionIds;
+    public IReadOnlyList<TemplateManifestItem> Variants { get; init; } = variants;
+}
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/TemplateManifestItem.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/TemplateManifestItem.cs
new file mode 100644
index 0000000..15f0c9b
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/TemplateManifestItem.cs
@@ -0,0 +1,8 @@
+namespace Eternelle.Modules.Catalog.Domain.Templates;
+
+public sealed record TemplateManifestItem(
+    string SectionId,
+    string Variant,
+    string PriceClass,
+    bool IsDefault,
+    int? UploadLimit);

From f1ca0cead11432ba4f623d781c57091b3956cb10 Mon Sep 17 00:00:00 2001
From: Carl Marion <carlmarion.develops@gmail.com>
Date: Wed, 27 May 2026 13:10:23 +0800
Subject: [PATCH 08/31] feat(catalog): add TemplateErrors

---
 .../Templates/TemplateErrors.cs               | 27 +++++++++++++++++++
 1 file changed, 27 insertions(+)
 create mode 100644 src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/TemplateErrors.cs

diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/TemplateErrors.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/TemplateErrors.cs
new file mode 100644
index 0000000..f53d8ec
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/TemplateErrors.cs
@@ -0,0 +1,27 @@
+using Eternelle.Common.Domain;
+
+namespace Eternelle.Modules.Catalog.Domain.Templates;
+
+public static class TemplateErrors
+{
+    public static Error NotFound(TemplateId id) =>
+        Error.NotFound("Catalog.Template.NotFound", $"Template '{id.Value}' was not found.");
+
+    public static readonly Error NameTaken =
+        Error.Conflict("Catalog.Template.NameTaken", "A template with this name already exists.");
+
+    public static readonly Error DuplicateThemeIndex =
+        Error.Conflict("Catalog.Template.DuplicateThemeIndex", "A theme with this index already exists for the template.");
+
+    public static readonly Error SectionAlreadySupported =
+        Error.Conflict("Catalog.Template.SectionAlreadySupported", "This section is already supported by the template.");
+
+    public static readonly Error SectionNotSupported =
+        Error.Problem("Catalog.Template.SectionNotSupported", "A variant cannot be added for a section the template does not support.");
+
+    public static readonly Error DuplicateDefaultVariant =
+        Error.Conflict("Catalog.Template.DuplicateDefaultVariant", "Only one default variant is allowed per section.");
+
+    public static readonly Error DuplicateVariant =
+        Error.Conflict("Catalog.Template.DuplicateVariant", "This variant already exists for the section.");
+}

From 8b245d68c1d3b257b9861d8fa959786f9dbf52fd Mon Sep 17 00:00:00 2001
From: Carl Marion <carlmarion.develops@gmail.com>
Date: Wed, 27 May 2026 13:11:55 +0800
Subject: [PATCH 09/31] feat(catalog): add Template aggregate root

---
 .../Templates/Template.cs                     | 152 ++++++++++++++++++
 1 file changed, 152 insertions(+)
 create mode 100644 src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/Template.cs

diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/Template.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/Template.cs
new file mode 100644
index 0000000..8115272
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/Template.cs
@@ -0,0 +1,152 @@
+using Eternelle.Common.Domain;
+using Eternelle.Modules.Catalog.Domain.Shared;
+
+namespace Eternelle.Modules.Catalog.Domain.Templates;
+
+public sealed class Template : Entity
+{
+    private readonly List<TemplateTheme> _themes = [];
+    private readonly List<TemplateSupportedSection> _supportedSections = [];
+    private readonly List<TemplateSectionVariant> _sectionVariants = [];
+
+    private Template() { }
+
+    public TemplateId Id { get; private set; }
+    public TemplateName Name { get; private set; } = null!;
+    public TemplateDescription? Description { get; private set; }
+    public TemplateTier Tier { get; private set; }
+    public ImageUrl? PreviewImageUrl { get; private set; }
+    public IReadOnlyList<string> Features { get; private set; } = [];
+    public DateTime CreatedAtUtc { get; private set; }
+    public DateTime UpdatedAtUtc { get; private set; }
+
+    public IReadOnlyCollection<TemplateTheme> Themes => _themes.AsReadOnly();
+    public IReadOnlyCollection<TemplateSupportedSection> SupportedSections => _supportedSections.AsReadOnly();
+    public IReadOnlyCollection<TemplateSectionVariant> SectionVariants => _sectionVariants.AsReadOnly();
+
+    public static Result<Template> Create(
+        TemplateName name,
+        TemplateDescription? description,
+        TemplateTier tier,
+        ImageUrl? previewImageUrl,
+        IReadOnlyList<string> features,
+        DateTime utcNow)
+    {
+        var template = new Template
+        {
+            Id = TemplateId.New(),
+            Name = name,
+            Description = description,
+            Tier = tier,
+            PreviewImageUrl = previewImageUrl,
+            Features = features,
+            CreatedAtUtc = utcNow,
+            UpdatedAtUtc = utcNow
+        };
+
+        template.Raise(new TemplateCreatedDomainEvent(template.Id, name.Value, tier.ToString()));
+        template.Raise(template.BuildManifestEvent());
+
+        return Result.Success(template);
+    }
+
+    public Result UpdateDetails(
+        TemplateName name,
+        TemplateDescription? description,
+        ImageUrl? previewImageUrl,
+        IReadOnlyList<string> features,
+        DateTime utcNow)
+    {
+        Name = name;
+        Description = description;
+        PreviewImageUrl = previewImageUrl;
+        Features = features;
+        UpdatedAtUtc = utcNow;
+
+        Raise(BuildManifestEvent());
+
+        return Result.Success();
+    }
+
+    public Result AddTheme(
+        int themeIndex,
+        TemplateThemeName name,
+        ThemeColors colors,
+        ThemeTypography typography,
+        ThemeTextures? textures,
+        bool isDark,
+        DateTime utcNow)
+    {
+        if (_themes.Any(t => t.ThemeIndex == themeIndex))
+        {
+            return Result.Failure(TemplateErrors.DuplicateThemeIndex);
+        }
+
+        _themes.Add(TemplateTheme.Create(Id, themeIndex, name, colors, typography, textures, isDark));
+        UpdatedAtUtc = utcNow;
+
+        Raise(BuildManifestEvent());
+
+        return Result.Success();
+    }
+
+    public Result AddSupportedSection(SectionId sectionId, int displayOrder, DateTime utcNow)
+    {
+        if (_supportedSections.Any(s => s.SectionId == sectionId))
+        {
+            return Result.Failure(TemplateErrors.SectionAlreadySupported);
+        }
+
+        _supportedSections.Add(TemplateSupportedSection.Create(Id, sectionId, displayOrder));
+        UpdatedAtUtc = utcNow;
+
+        Raise(BuildManifestEvent());
+
+        return Result.Success();
+    }
+
+    public Result AddSectionVariant(
+        SectionId sectionId,
+        string variant,
+        bool isDefault,
+        PriceClass priceClass,
+        int? uploadLimit,
+        DateTime utcNow)
+    {
+        if (_supportedSections.All(s => s.SectionId != sectionId))
+        {
+            return Result.Failure(TemplateErrors.SectionNotSupported);
+        }
+
+        if (_sectionVariants.Any(v => v.SectionId == sectionId &&
+                                      string.Equals(v.Variant, variant, StringComparison.OrdinalIgnoreCase)))
+        {
+            return Result.Failure(TemplateErrors.DuplicateVariant);
+        }
+
+        if (isDefault && _sectionVariants.Any(v => v.SectionId == sectionId && v.IsDefault))
+        {
+            return Result.Failure(TemplateErrors.DuplicateDefaultVariant);
+        }
+
+        _sectionVariants.Add(TemplateSectionVariant.Create(Id, sectionId, variant, isDefault, priceClass, uploadLimit));
+        UpdatedAtUtc = utcNow;
+
+        Raise(BuildManifestEvent());
+
+        return Result.Success();
+    }
+
+    private TemplateManifestChangedDomainEvent BuildManifestEvent() =>
+        new(
+            Id,
+            Name.Value,
+            Tier.ToString(),
+            [.. _supportedSections.Select(s => s.SectionId.ToString())],
+            [.. _sectionVariants.Select(v => new TemplateManifestItem(
+                v.SectionId.ToString(),
+                v.Variant,
+                v.PriceClass.ToString(),
+                v.IsDefault,
+                v.UploadLimit))]);
+}

From ba49d6eb7fb2d3d4c59bd162edcb6dfc466ef8da Mon Sep 17 00:00:00 2001
From: Carl Marion <carlmarion.develops@gmail.com>
Date: Wed, 27 May 2026 13:12:34 +0800
Subject: [PATCH 10/31] feat(catalog): add ITemplateRepository

---
 .../Templates/ITemplateRepository.cs                 | 12 ++++++++++++
 1 file changed, 12 insertions(+)
 create mode 100644 src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/ITemplateRepository.cs

diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/ITemplateRepository.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/ITemplateRepository.cs
new file mode 100644
index 0000000..0a589a7
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/ITemplateRepository.cs
@@ -0,0 +1,12 @@
+namespace Eternelle.Modules.Catalog.Domain.Templates;
+
+public interface ITemplateRepository
+{
+    Task<Template?> GetAsync(TemplateId id, CancellationToken cancellationToken = default);
+
+    Task<bool> NameExistsAsync(string name, CancellationToken cancellationToken = default);
+
+    void Insert(Template template);
+
+    void Update(Template template);
+}

From 0eb10cf3d57d5d1f844825ab462db9f33df51354 Mon Sep 17 00:00:00 2001
From: Carl Marion <carlmarion.develops@gmail.com>
Date: Wed, 27 May 2026 13:19:07 +0800
Subject: [PATCH 11/31] style(catalog): remove what-comment from UploadLimit
 property

---
 .../Templates/TemplateSectionVariant.cs                          | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/TemplateSectionVariant.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/TemplateSectionVariant.cs
index 0f719e7..a191bbe 100644
--- a/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/TemplateSectionVariant.cs
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/TemplateSectionVariant.cs
@@ -13,7 +13,6 @@ private TemplateSectionVariant() { }
     public bool IsDefault { get; private set; }
     public PriceClass PriceClass { get; private set; }
 
-    // Upload cap for upload-capable sections (e.g. GuestUploads). null = unlimited / N/A.
     public int? UploadLimit { get; private set; }
 
     internal static TemplateSectionVariant Create(

From 724f3fec6d89642bf37c3db0a5bd3b84b92ff45f Mon Sep 17 00:00:00 2001
From: Carl Marion <carlmarion.develops@gmail.com>
Date: Wed, 27 May 2026 13:24:41 +0800
Subject: [PATCH 12/31] Eternelle-180 Add CatalogTemplateManifestChanged
 integration event

---
 ...TemplateManifestChangedIntegrationEvent.cs | 29 +++++++++++++++++++
 .../SectionVariantManifest.cs                 |  8 +++++
 2 files changed, 37 insertions(+)
 create mode 100644 src/Modules/Catalog/Eternelle.Modules.Catalog.IntegrationEvents/CatalogTemplateManifestChangedIntegrationEvent.cs
 create mode 100644 src/Modules/Catalog/Eternelle.Modules.Catalog.IntegrationEvents/SectionVariantManifest.cs

diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.IntegrationEvents/CatalogTemplateManifestChangedIntegrationEvent.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.IntegrationEvents/CatalogTemplateManifestChangedIntegrationEvent.cs
new file mode 100644
index 0000000..2b2dc6c
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.IntegrationEvents/CatalogTemplateManifestChangedIntegrationEvent.cs
@@ -0,0 +1,29 @@
+using Eternelle.Common.Application.EventBus;
+
+namespace Eternelle.Modules.Catalog.IntegrationEvents;
+
+public sealed class CatalogTemplateManifestChangedIntegrationEvent : IntegrationEvent
+{
+    public CatalogTemplateManifestChangedIntegrationEvent(
+        Guid id,
+        DateTime occurredOnUtc,
+        Guid templateId,
+        string name,
+        string tier,
+        IReadOnlyList<string> sectionIds,
+        IReadOnlyList<SectionVariantManifest> variants)
+        : base(id, occurredOnUtc)
+    {
+        TemplateId = templateId;
+        Name = name;
+        Tier = tier;
+        SectionIds = sectionIds;
+        Variants = variants;
+    }
+
+    public Guid TemplateId { get; init; }
+    public string Name { get; init; }
+    public string Tier { get; init; }
+    public IReadOnlyList<string> SectionIds { get; init; }
+    public IReadOnlyList<SectionVariantManifest> Variants { get; init; }
+}
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.IntegrationEvents/SectionVariantManifest.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.IntegrationEvents/SectionVariantManifest.cs
new file mode 100644
index 0000000..1a4888f
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.IntegrationEvents/SectionVariantManifest.cs
@@ -0,0 +1,8 @@
+namespace Eternelle.Modules.Catalog.IntegrationEvents;
+
+public sealed record SectionVariantManifest(
+    string SectionId,
+    string Variant,
+    string PriceClass,
+    bool IsDefault,
+    int? UploadLimit);

From 29b8351d4b3ec76ef2f937f80d4e746710160395 Mon Sep 17 00:00:00 2001
From: Carl Marion <carlmarion.develops@gmail.com>
Date: Wed, 27 May 2026 14:38:45 +0800
Subject: [PATCH 13/31] Eternelle-180 Add IUnitOfWork and manifest domain-event
 handler

---
 .../Abstractions/Data/IUnitOfWork.cs          |  6 +++++
 ...mplateManifestChangedDomainEventHandler.cs | 27 +++++++++++++++++++
 2 files changed, 33 insertions(+)
 create mode 100644 src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Abstractions/Data/IUnitOfWork.cs
 create mode 100644 src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/TemplateManifestChangedDomainEventHandler.cs

diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Abstractions/Data/IUnitOfWork.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Abstractions/Data/IUnitOfWork.cs
new file mode 100644
index 0000000..a47c928
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Abstractions/Data/IUnitOfWork.cs
@@ -0,0 +1,6 @@
+namespace Eternelle.Modules.Catalog.Application.Abstractions.Data;
+
+public interface IUnitOfWork
+{
+    Task<int> SaveChangesAsync(CancellationToken cancellationToken = default);
+}
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/TemplateManifestChangedDomainEventHandler.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/TemplateManifestChangedDomainEventHandler.cs
new file mode 100644
index 0000000..a9f5c8e
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/TemplateManifestChangedDomainEventHandler.cs
@@ -0,0 +1,27 @@
+using Eternelle.Common.Application.EventBus;
+using Eternelle.Common.Application.Messaging;
+using Eternelle.Modules.Catalog.Domain.Templates;
+using Eternelle.Modules.Catalog.IntegrationEvents;
+
+namespace Eternelle.Modules.Catalog.Application.Templates;
+
+internal sealed class TemplateManifestChangedDomainEventHandler(IEventBus eventBus)
+    : DomainEventHandler<TemplateManifestChangedDomainEvent>
+{
+    public override async Task Handle(
+        TemplateManifestChangedDomainEvent domainEvent,
+        CancellationToken cancellationToken = default)
+    {
+        await eventBus.PublishAsync(
+            new CatalogTemplateManifestChangedIntegrationEvent(
+                domainEvent.Id,
+                domainEvent.OccurredOnUtc,
+                domainEvent.TemplateId.Value,
+                domainEvent.Name,
+                domainEvent.Tier,
+                domainEvent.SectionIds,
+                [.. domainEvent.Variants.Select(v => new SectionVariantManifest(
+                    v.SectionId, v.Variant, v.PriceClass, v.IsDefault, v.UploadLimit))]),
+            cancellationToken);
+    }
+}

From 033c22c6f424d13ec6af4c3e00d6e5e65eb92267 Mon Sep 17 00:00:00 2001
From: Carl Marion <carlmarion.develops@gmail.com>
Date: Wed, 27 May 2026 14:44:29 +0800
Subject: [PATCH 14/31] Eternelle-180 Add CreateTemplate command and cache keys

---
 .../Templates/CatalogCacheKeys.cs             | 18 +++++
 .../CreateTemplate/CreateTemplateCommand.cs   | 11 +++
 .../CreateTemplateCommandHandler.cs           | 75 +++++++++++++++++++
 .../CreateTemplateCommandValidator.cs         | 16 ++++
 4 files changed, 120 insertions(+)
 create mode 100644 src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/CatalogCacheKeys.cs
 create mode 100644 src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/CreateTemplate/CreateTemplateCommand.cs
 create mode 100644 src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/CreateTemplate/CreateTemplateCommandHandler.cs
 create mode 100644 src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/CreateTemplate/CreateTemplateCommandValidator.cs

diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/CatalogCacheKeys.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/CatalogCacheKeys.cs
new file mode 100644
index 0000000..3c462ce
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/CatalogCacheKeys.cs
@@ -0,0 +1,18 @@
+using Eternelle.Modules.Catalog.Domain.Templates;
+
+namespace Eternelle.Modules.Catalog.Application.Templates;
+
+internal static class CatalogCacheKeys
+{
+    public static string TemplateById(Guid templateId) => $"catalog:template:{templateId}";
+
+    public static string TemplateList(TemplateTier? tier) =>
+        tier is null ? "catalog:templates:all" : $"catalog:templates:{tier}";
+
+    public static IReadOnlyList<string> AllTemplateListKeys() =>
+    [
+        TemplateList(null),
+        TemplateList(TemplateTier.FirstClass),
+        TemplateList(TemplateTier.Signature)
+    ];
+}
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/CreateTemplate/CreateTemplateCommand.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/CreateTemplate/CreateTemplateCommand.cs
new file mode 100644
index 0000000..8af09bb
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/CreateTemplate/CreateTemplateCommand.cs
@@ -0,0 +1,11 @@
+using Eternelle.Common.Application.Messaging;
+using Eternelle.Modules.Catalog.Domain.Templates;
+
+namespace Eternelle.Modules.Catalog.Application.Templates.CreateTemplate;
+
+public sealed record CreateTemplateCommand(
+    string Name,
+    string? Description,
+    TemplateTier Tier,
+    string? PreviewImageUrl,
+    IReadOnlyList<string>? Features) : ICommand<Guid>;
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/CreateTemplate/CreateTemplateCommandHandler.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/CreateTemplate/CreateTemplateCommandHandler.cs
new file mode 100644
index 0000000..bbc812f
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/CreateTemplate/CreateTemplateCommandHandler.cs
@@ -0,0 +1,75 @@
+using Eternelle.Common.Application.Caching;
+using Eternelle.Common.Application.Clock;
+using Eternelle.Common.Application.Messaging;
+using Eternelle.Common.Domain;
+using Eternelle.Modules.Catalog.Application.Abstractions.Data;
+using Eternelle.Modules.Catalog.Domain.Shared;
+using Eternelle.Modules.Catalog.Domain.Templates;
+
+namespace Eternelle.Modules.Catalog.Application.Templates.CreateTemplate;
+
+internal sealed class CreateTemplateCommandHandler(
+    ITemplateRepository templateRepository,
+    IUnitOfWork unitOfWork,
+    ICacheService cacheService,
+    IDateTimeProvider dateTimeProvider) : ICommandHandler<CreateTemplateCommand, Guid>
+{
+    public async Task<Result<Guid>> Handle(CreateTemplateCommand command, CancellationToken cancellationToken)
+    {
+        Result<TemplateName> nameResult = TemplateName.Create(command.Name);
+        if (nameResult.IsFailure)
+        {
+            return Result.Failure<Guid>(nameResult.Error);
+        }
+
+        TemplateDescription? description = null;
+        if (command.Description is not null)
+        {
+            Result<TemplateDescription> descriptionResult = TemplateDescription.Create(command.Description);
+            if (descriptionResult.IsFailure)
+            {
+                return Result.Failure<Guid>(descriptionResult.Error);
+            }
+            description = descriptionResult.Value;
+        }
+
+        ImageUrl? previewImageUrl = null;
+        if (command.PreviewImageUrl is not null)
+        {
+            Result<ImageUrl> previewResult = ImageUrl.Create(command.PreviewImageUrl);
+            if (previewResult.IsFailure)
+            {
+                return Result.Failure<Guid>(previewResult.Error);
+            }
+            previewImageUrl = previewResult.Value;
+        }
+
+        if (await templateRepository.NameExistsAsync(nameResult.Value.Value, cancellationToken))
+        {
+            return Result.Failure<Guid>(TemplateErrors.NameTaken);
+        }
+
+        Result<Template> templateResult = Template.Create(
+            nameResult.Value,
+            description,
+            command.Tier,
+            previewImageUrl,
+            command.Features ?? [],
+            dateTimeProvider.UtcNow);
+
+        if (templateResult.IsFailure)
+        {
+            return Result.Failure<Guid>(templateResult.Error);
+        }
+
+        templateRepository.Insert(templateResult.Value);
+        await unitOfWork.SaveChangesAsync(cancellationToken);
+
+        foreach (string key in CatalogCacheKeys.AllTemplateListKeys())
+        {
+            await cacheService.RemoveAsync(key, cancellationToken);
+        }
+
+        return templateResult.Value.Id.Value;
+    }
+}
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/CreateTemplate/CreateTemplateCommandValidator.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/CreateTemplate/CreateTemplateCommandValidator.cs
new file mode 100644
index 0000000..c6cb900
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/CreateTemplate/CreateTemplateCommandValidator.cs
@@ -0,0 +1,16 @@
+using Eternelle.Modules.Catalog.Domain.Shared;
+using Eternelle.Modules.Catalog.Domain.Templates;
+using FluentValidation;
+
+namespace Eternelle.Modules.Catalog.Application.Templates.CreateTemplate;
+
+internal sealed class CreateTemplateCommandValidator : AbstractValidator<CreateTemplateCommand>
+{
+    public CreateTemplateCommandValidator()
+    {
+        RuleFor(c => c.Name).NotEmpty().MaximumLength(TemplateName.MaxLength);
+        RuleFor(c => c.Description).MaximumLength(TemplateDescription.MaxLength).When(c => c.Description is not null);
+        RuleFor(c => c.Tier).IsInEnum();
+        RuleFor(c => c.PreviewImageUrl).MaximumLength(ImageUrl.MaxLength).When(c => c.PreviewImageUrl is not null);
+    }
+}

From 5027920b5cc5fe23ab76ca5d28741da70437bbf1 Mon Sep 17 00:00:00 2001
From: Carl Marion <carlmarion.develops@gmail.com>
Date: Wed, 27 May 2026 14:46:22 +0800
Subject: [PATCH 15/31] Eternelle-180 Add UpdateTemplate command

---
 .../UpdateTemplate/UpdateTemplateCommand.cs   | 10 +++
 .../UpdateTemplateCommandHandler.cs           | 82 +++++++++++++++++++
 .../UpdateTemplateCommandValidator.cs         | 16 ++++
 3 files changed, 108 insertions(+)
 create mode 100644 src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/UpdateTemplate/UpdateTemplateCommand.cs
 create mode 100644 src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/UpdateTemplate/UpdateTemplateCommandHandler.cs
 create mode 100644 src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/UpdateTemplate/UpdateTemplateCommandValidator.cs

diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/UpdateTemplate/UpdateTemplateCommand.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/UpdateTemplate/UpdateTemplateCommand.cs
new file mode 100644
index 0000000..c4c468c
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/UpdateTemplate/UpdateTemplateCommand.cs
@@ -0,0 +1,10 @@
+using Eternelle.Common.Application.Messaging;
+
+namespace Eternelle.Modules.Catalog.Application.Templates.UpdateTemplate;
+
+public sealed record UpdateTemplateCommand(
+    Guid TemplateId,
+    string Name,
+    string? Description,
+    string? PreviewImageUrl,
+    IReadOnlyList<string>? Features) : ICommand;
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/UpdateTemplate/UpdateTemplateCommandHandler.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/UpdateTemplate/UpdateTemplateCommandHandler.cs
new file mode 100644
index 0000000..cdcebf3
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/UpdateTemplate/UpdateTemplateCommandHandler.cs
@@ -0,0 +1,82 @@
+using Eternelle.Common.Application.Caching;
+using Eternelle.Common.Application.Clock;
+using Eternelle.Common.Application.Messaging;
+using Eternelle.Common.Domain;
+using Eternelle.Modules.Catalog.Application.Abstractions.Data;
+using Eternelle.Modules.Catalog.Domain.Shared;
+using Eternelle.Modules.Catalog.Domain.Templates;
+
+namespace Eternelle.Modules.Catalog.Application.Templates.UpdateTemplate;
+
+internal sealed class UpdateTemplateCommandHandler(
+    ITemplateRepository templateRepository,
+    IUnitOfWork unitOfWork,
+    ICacheService cacheService,
+    IDateTimeProvider dateTimeProvider) : ICommandHandler<UpdateTemplateCommand>
+{
+    public async Task<Result> Handle(UpdateTemplateCommand command, CancellationToken cancellationToken)
+    {
+        Template? template = await templateRepository.GetAsync(new TemplateId(command.TemplateId), cancellationToken);
+        if (template is null)
+        {
+            return Result.Failure(TemplateErrors.NotFound(new TemplateId(command.TemplateId)));
+        }
+
+        Result<TemplateName> nameResult = TemplateName.Create(command.Name);
+        if (nameResult.IsFailure)
+        {
+            return Result.Failure(nameResult.Error);
+        }
+
+        if (!string.Equals(nameResult.Value.Value, template.Name.Value, StringComparison.Ordinal) &&
+            await templateRepository.NameExistsAsync(nameResult.Value.Value, cancellationToken))
+        {
+            return Result.Failure(TemplateErrors.NameTaken);
+        }
+
+        TemplateDescription? description = null;
+        if (command.Description is not null)
+        {
+            Result<TemplateDescription> descriptionResult = TemplateDescription.Create(command.Description);
+            if (descriptionResult.IsFailure)
+            {
+                return Result.Failure(descriptionResult.Error);
+            }
+            description = descriptionResult.Value;
+        }
+
+        ImageUrl? previewImageUrl = null;
+        if (command.PreviewImageUrl is not null)
+        {
+            Result<ImageUrl> previewResult = ImageUrl.Create(command.PreviewImageUrl);
+            if (previewResult.IsFailure)
+            {
+                return Result.Failure(previewResult.Error);
+            }
+            previewImageUrl = previewResult.Value;
+        }
+
+        Result updateResult = template.UpdateDetails(
+            nameResult.Value, description, previewImageUrl, command.Features ?? [], dateTimeProvider.UtcNow);
+        if (updateResult.IsFailure)
+        {
+            return updateResult;
+        }
+
+        templateRepository.Update(template);
+        await unitOfWork.SaveChangesAsync(cancellationToken);
+
+        await InvalidateAsync(cacheService, command.TemplateId, cancellationToken);
+
+        return Result.Success();
+    }
+
+    private static async Task InvalidateAsync(ICacheService cacheService, Guid templateId, CancellationToken cancellationToken)
+    {
+        await cacheService.RemoveAsync(CatalogCacheKeys.TemplateById(templateId), cancellationToken);
+        foreach (string key in CatalogCacheKeys.AllTemplateListKeys())
+        {
+            await cacheService.RemoveAsync(key, cancellationToken);
+        }
+    }
+}
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/UpdateTemplate/UpdateTemplateCommandValidator.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/UpdateTemplate/UpdateTemplateCommandValidator.cs
new file mode 100644
index 0000000..1897dc7
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/UpdateTemplate/UpdateTemplateCommandValidator.cs
@@ -0,0 +1,16 @@
+using Eternelle.Modules.Catalog.Domain.Shared;
+using Eternelle.Modules.Catalog.Domain.Templates;
+using FluentValidation;
+
+namespace Eternelle.Modules.Catalog.Application.Templates.UpdateTemplate;
+
+internal sealed class UpdateTemplateCommandValidator : AbstractValidator<UpdateTemplateCommand>
+{
+    public UpdateTemplateCommandValidator()
+    {
+        RuleFor(c => c.TemplateId).NotEmpty();
+        RuleFor(c => c.Name).NotEmpty().MaximumLength(TemplateName.MaxLength);
+        RuleFor(c => c.Description).MaximumLength(TemplateDescription.MaxLength).When(c => c.Description is not null);
+        RuleFor(c => c.PreviewImageUrl).MaximumLength(ImageUrl.MaxLength).When(c => c.PreviewImageUrl is not null);
+    }
+}

From 09703e648b10dcbfe28ecf42687d2a12108511fb Mon Sep 17 00:00:00 2001
From: Carl Marion <carlmarion.develops@gmail.com>
Date: Wed, 27 May 2026 14:49:17 +0800
Subject: [PATCH 16/31] Eternelle-180 Add AddTemplateTheme command

---
 .../AddTemplateThemeCommand.cs                | 12 +++++
 .../AddTemplateThemeCommandHandler.cs         | 48 +++++++++++++++++++
 .../AddTemplateThemeCommandValidator.cs       | 16 +++++++
 3 files changed, 76 insertions(+)
 create mode 100644 src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/AddTemplateTheme/AddTemplateThemeCommand.cs
 create mode 100644 src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/AddTemplateTheme/AddTemplateThemeCommandHandler.cs
 create mode 100644 src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/AddTemplateTheme/AddTemplateThemeCommandValidator.cs

diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/AddTemplateTheme/AddTemplateThemeCommand.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/AddTemplateTheme/AddTemplateThemeCommand.cs
new file mode 100644
index 0000000..4b5806e
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/AddTemplateTheme/AddTemplateThemeCommand.cs
@@ -0,0 +1,12 @@
+using Eternelle.Common.Application.Messaging;
+
+namespace Eternelle.Modules.Catalog.Application.Templates.AddTemplateTheme;
+
+public sealed record AddTemplateThemeCommand(
+    Guid TemplateId,
+    int ThemeIndex,
+    string Name,
+    IReadOnlyDictionary<string, string> Colors,
+    IReadOnlyDictionary<string, string> Typography,
+    IReadOnlyDictionary<string, string>? Textures,
+    bool IsDark) : ICommand;
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/AddTemplateTheme/AddTemplateThemeCommandHandler.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/AddTemplateTheme/AddTemplateThemeCommandHandler.cs
new file mode 100644
index 0000000..5dca8fc
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/AddTemplateTheme/AddTemplateThemeCommandHandler.cs
@@ -0,0 +1,48 @@
+using Eternelle.Common.Application.Caching;
+using Eternelle.Common.Application.Clock;
+using Eternelle.Common.Application.Messaging;
+using Eternelle.Common.Domain;
+using Eternelle.Modules.Catalog.Application.Abstractions.Data;
+using Eternelle.Modules.Catalog.Domain.Templates;
+
+namespace Eternelle.Modules.Catalog.Application.Templates.AddTemplateTheme;
+
+internal sealed class AddTemplateThemeCommandHandler(
+    ITemplateRepository templateRepository,
+    IUnitOfWork unitOfWork,
+    ICacheService cacheService,
+    IDateTimeProvider dateTimeProvider) : ICommandHandler<AddTemplateThemeCommand>
+{
+    public async Task<Result> Handle(AddTemplateThemeCommand command, CancellationToken cancellationToken)
+    {
+        Template? template = await templateRepository.GetAsync(new TemplateId(command.TemplateId), cancellationToken);
+        if (template is null)
+        {
+            return Result.Failure(TemplateErrors.NotFound(new TemplateId(command.TemplateId)));
+        }
+
+        Result<TemplateThemeName> nameResult = TemplateThemeName.Create(command.Name);
+        if (nameResult.IsFailure)
+        {
+            return Result.Failure(nameResult.Error);
+        }
+
+        var colors = new ThemeColors(command.Colors);
+        var typography = new ThemeTypography(command.Typography);
+        ThemeTextures? textures = command.Textures is null ? null : new ThemeTextures(command.Textures);
+
+        Result addResult = template.AddTheme(
+            command.ThemeIndex, nameResult.Value, colors, typography, textures, command.IsDark, dateTimeProvider.UtcNow);
+        if (addResult.IsFailure)
+        {
+            return addResult;
+        }
+
+        templateRepository.Update(template);
+        await unitOfWork.SaveChangesAsync(cancellationToken);
+
+        await cacheService.RemoveAsync(CatalogCacheKeys.TemplateById(command.TemplateId), cancellationToken);
+
+        return Result.Success();
+    }
+}
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/AddTemplateTheme/AddTemplateThemeCommandValidator.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/AddTemplateTheme/AddTemplateThemeCommandValidator.cs
new file mode 100644
index 0000000..0ec91a8
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/AddTemplateTheme/AddTemplateThemeCommandValidator.cs
@@ -0,0 +1,16 @@
+using Eternelle.Modules.Catalog.Domain.Templates;
+using FluentValidation;
+
+namespace Eternelle.Modules.Catalog.Application.Templates.AddTemplateTheme;
+
+internal sealed class AddTemplateThemeCommandValidator : AbstractValidator<AddTemplateThemeCommand>
+{
+    public AddTemplateThemeCommandValidator()
+    {
+        RuleFor(c => c.TemplateId).NotEmpty();
+        RuleFor(c => c.ThemeIndex).GreaterThanOrEqualTo(0);
+        RuleFor(c => c.Name).NotEmpty().MaximumLength(TemplateThemeName.MaxLength);
+        RuleFor(c => c.Colors).NotEmpty();
+        RuleFor(c => c.Typography).NotEmpty();
+    }
+}

From 8c828d5bf40928cfac7109de0af7cb1761690b4a Mon Sep 17 00:00:00 2001
From: Carl Marion <carlmarion.develops@gmail.com>
Date: Wed, 27 May 2026 14:50:12 +0800
Subject: [PATCH 17/31] Eternelle-180 Add AddSupportedSection command

---
 .../AddSupportedSectionCommand.cs             |  9 +++++
 .../AddSupportedSectionCommandHandler.cs      | 37 +++++++++++++++++++
 .../AddSupportedSectionCommandValidator.cs    | 13 +++++++
 3 files changed, 59 insertions(+)
 create mode 100644 src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/AddSupportedSection/AddSupportedSectionCommand.cs
 create mode 100644 src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/AddSupportedSection/AddSupportedSectionCommandHandler.cs
 create mode 100644 src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/AddSupportedSection/AddSupportedSectionCommandValidator.cs

diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/AddSupportedSection/AddSupportedSectionCommand.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/AddSupportedSection/AddSupportedSectionCommand.cs
new file mode 100644
index 0000000..68cfaf0
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/AddSupportedSection/AddSupportedSectionCommand.cs
@@ -0,0 +1,9 @@
+using Eternelle.Common.Application.Messaging;
+using Eternelle.Modules.Catalog.Domain.Templates;
+
+namespace Eternelle.Modules.Catalog.Application.Templates.AddSupportedSection;
+
+public sealed record AddSupportedSectionCommand(
+    Guid TemplateId,
+    SectionId SectionId,
+    int DisplayOrder) : ICommand;
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/AddSupportedSection/AddSupportedSectionCommandHandler.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/AddSupportedSection/AddSupportedSectionCommandHandler.cs
new file mode 100644
index 0000000..a988833
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/AddSupportedSection/AddSupportedSectionCommandHandler.cs
@@ -0,0 +1,37 @@
+using Eternelle.Common.Application.Caching;
+using Eternelle.Common.Application.Clock;
+using Eternelle.Common.Application.Messaging;
+using Eternelle.Common.Domain;
+using Eternelle.Modules.Catalog.Application.Abstractions.Data;
+using Eternelle.Modules.Catalog.Domain.Templates;
+
+namespace Eternelle.Modules.Catalog.Application.Templates.AddSupportedSection;
+
+internal sealed class AddSupportedSectionCommandHandler(
+    ITemplateRepository templateRepository,
+    IUnitOfWork unitOfWork,
+    ICacheService cacheService,
+    IDateTimeProvider dateTimeProvider) : ICommandHandler<AddSupportedSectionCommand>
+{
+    public async Task<Result> Handle(AddSupportedSectionCommand command, CancellationToken cancellationToken)
+    {
+        Template? template = await templateRepository.GetAsync(new TemplateId(command.TemplateId), cancellationToken);
+        if (template is null)
+        {
+            return Result.Failure(TemplateErrors.NotFound(new TemplateId(command.TemplateId)));
+        }
+
+        Result addResult = template.AddSupportedSection(command.SectionId, command.DisplayOrder, dateTimeProvider.UtcNow);
+        if (addResult.IsFailure)
+        {
+            return addResult;
+        }
+
+        templateRepository.Update(template);
+        await unitOfWork.SaveChangesAsync(cancellationToken);
+
+        await cacheService.RemoveAsync(CatalogCacheKeys.TemplateById(command.TemplateId), cancellationToken);
+
+        return Result.Success();
+    }
+}
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/AddSupportedSection/AddSupportedSectionCommandValidator.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/AddSupportedSection/AddSupportedSectionCommandValidator.cs
new file mode 100644
index 0000000..be601cc
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/AddSupportedSection/AddSupportedSectionCommandValidator.cs
@@ -0,0 +1,13 @@
+using FluentValidation;
+
+namespace Eternelle.Modules.Catalog.Application.Templates.AddSupportedSection;
+
+internal sealed class AddSupportedSectionCommandValidator : AbstractValidator<AddSupportedSectionCommand>
+{
+    public AddSupportedSectionCommandValidator()
+    {
+        RuleFor(c => c.TemplateId).NotEmpty();
+        RuleFor(c => c.SectionId).IsInEnum();
+        RuleFor(c => c.DisplayOrder).GreaterThanOrEqualTo(0);
+    }
+}

From 942a68bc5a76c96a323a7314432d04546b1df61a Mon Sep 17 00:00:00 2001
From: Carl Marion <carlmarion.develops@gmail.com>
Date: Wed, 27 May 2026 14:51:53 +0800
Subject: [PATCH 18/31] Eternelle-180 Add AddSectionVariant command with upload
 limit

---
 .../AddSectionVariantCommand.cs               | 12 ++++++
 .../AddSectionVariantCommandHandler.cs        | 39 +++++++++++++++++++
 .../AddSectionVariantCommandValidator.cs      | 15 +++++++
 3 files changed, 66 insertions(+)
 create mode 100644 src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/AddSectionVariant/AddSectionVariantCommand.cs
 create mode 100644 src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/AddSectionVariant/AddSectionVariantCommandHandler.cs
 create mode 100644 src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/AddSectionVariant/AddSectionVariantCommandValidator.cs

diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/AddSectionVariant/AddSectionVariantCommand.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/AddSectionVariant/AddSectionVariantCommand.cs
new file mode 100644
index 0000000..3f7a747
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/AddSectionVariant/AddSectionVariantCommand.cs
@@ -0,0 +1,12 @@
+using Eternelle.Common.Application.Messaging;
+using Eternelle.Modules.Catalog.Domain.Templates;
+
+namespace Eternelle.Modules.Catalog.Application.Templates.AddSectionVariant;
+
+public sealed record AddSectionVariantCommand(
+    Guid TemplateId,
+    SectionId SectionId,
+    string Variant,
+    bool IsDefault,
+    PriceClass PriceClass,
+    int? UploadLimit) : ICommand;
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/AddSectionVariant/AddSectionVariantCommandHandler.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/AddSectionVariant/AddSectionVariantCommandHandler.cs
new file mode 100644
index 0000000..4dcd906
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/AddSectionVariant/AddSectionVariantCommandHandler.cs
@@ -0,0 +1,39 @@
+using Eternelle.Common.Application.Caching;
+using Eternelle.Common.Application.Clock;
+using Eternelle.Common.Application.Messaging;
+using Eternelle.Common.Domain;
+using Eternelle.Modules.Catalog.Application.Abstractions.Data;
+using Eternelle.Modules.Catalog.Domain.Templates;
+
+namespace Eternelle.Modules.Catalog.Application.Templates.AddSectionVariant;
+
+internal sealed class AddSectionVariantCommandHandler(
+    ITemplateRepository templateRepository,
+    IUnitOfWork unitOfWork,
+    ICacheService cacheService,
+    IDateTimeProvider dateTimeProvider) : ICommandHandler<AddSectionVariantCommand>
+{
+    public async Task<Result> Handle(AddSectionVariantCommand command, CancellationToken cancellationToken)
+    {
+        Template? template = await templateRepository.GetAsync(new TemplateId(command.TemplateId), cancellationToken);
+        if (template is null)
+        {
+            return Result.Failure(TemplateErrors.NotFound(new TemplateId(command.TemplateId)));
+        }
+
+        Result addResult = template.AddSectionVariant(
+            command.SectionId, command.Variant.Trim(), command.IsDefault, command.PriceClass,
+            command.UploadLimit, dateTimeProvider.UtcNow);
+        if (addResult.IsFailure)
+        {
+            return addResult;
+        }
+
+        templateRepository.Update(template);
+        await unitOfWork.SaveChangesAsync(cancellationToken);
+
+        await cacheService.RemoveAsync(CatalogCacheKeys.TemplateById(command.TemplateId), cancellationToken);
+
+        return Result.Success();
+    }
+}
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/AddSectionVariant/AddSectionVariantCommandValidator.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/AddSectionVariant/AddSectionVariantCommandValidator.cs
new file mode 100644
index 0000000..38957de
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/AddSectionVariant/AddSectionVariantCommandValidator.cs
@@ -0,0 +1,15 @@
+using FluentValidation;
+
+namespace Eternelle.Modules.Catalog.Application.Templates.AddSectionVariant;
+
+internal sealed class AddSectionVariantCommandValidator : AbstractValidator<AddSectionVariantCommand>
+{
+    public AddSectionVariantCommandValidator()
+    {
+        RuleFor(c => c.TemplateId).NotEmpty();
+        RuleFor(c => c.SectionId).IsInEnum();
+        RuleFor(c => c.Variant).NotEmpty().MaximumLength(100);
+        RuleFor(c => c.PriceClass).IsInEnum();
+        RuleFor(c => c.UploadLimit).GreaterThan(0).When(c => c.UploadLimit is not null);
+    }
+}

From febdab8534c4c764964ca1bea77557ada1cff58f Mon Sep 17 00:00:00 2001
From: Carl Marion <carlmarion.develops@gmail.com>
Date: Wed, 27 May 2026 14:57:24 +0800
Subject: [PATCH 19/31] Eternelle-180 Add GetTemplates query

---
 .../GetTemplates/GetTemplatesQuery.cs         |  7 +++
 .../GetTemplates/GetTemplatesQueryHandler.cs  | 52 +++++++++++++++++++
 .../GetTemplates/TemplateSummaryResponse.cs   |  8 +++
 3 files changed, 67 insertions(+)
 create mode 100644 src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/GetTemplates/GetTemplatesQuery.cs
 create mode 100644 src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/GetTemplates/GetTemplatesQueryHandler.cs
 create mode 100644 src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/GetTemplates/TemplateSummaryResponse.cs

diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/GetTemplates/GetTemplatesQuery.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/GetTemplates/GetTemplatesQuery.cs
new file mode 100644
index 0000000..30f0c72
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/GetTemplates/GetTemplatesQuery.cs
@@ -0,0 +1,7 @@
+using Eternelle.Common.Application.Messaging;
+using Eternelle.Modules.Catalog.Domain.Templates;
+
+namespace Eternelle.Modules.Catalog.Application.Templates.GetTemplates;
+
+public sealed record GetTemplatesQuery(TemplateTier? Tier)
+    : IQuery<IReadOnlyList<TemplateSummaryResponse>>;
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/GetTemplates/GetTemplatesQueryHandler.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/GetTemplates/GetTemplatesQueryHandler.cs
new file mode 100644
index 0000000..ba986fd
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/GetTemplates/GetTemplatesQueryHandler.cs
@@ -0,0 +1,52 @@
+using System.Data.Common;
+using Dapper;
+using Eternelle.Common.Application.Caching;
+using Eternelle.Common.Application.Data;
+using Eternelle.Common.Application.Messaging;
+using Eternelle.Common.Domain;
+
+namespace Eternelle.Modules.Catalog.Application.Templates.GetTemplates;
+
+internal sealed class GetTemplatesQueryHandler(
+    IDbConnectionFactory dbConnectionFactory,
+    ICacheService cacheService)
+    : IQueryHandler<GetTemplatesQuery, IReadOnlyList<TemplateSummaryResponse>>
+{
+    public async Task<Result<IReadOnlyList<TemplateSummaryResponse>>> Handle(
+        GetTemplatesQuery query,
+        CancellationToken cancellationToken)
+    {
+        string cacheKey = CatalogCacheKeys.TemplateList(query.Tier);
+
+        IReadOnlyList<TemplateSummaryResponse>? cached =
+            await cacheService.GetAsync<IReadOnlyList<TemplateSummaryResponse>>(cacheKey, cancellationToken);
+        if (cached is not null)
+        {
+            return Result.Success(cached);
+        }
+
+        await using DbConnection connection = await dbConnectionFactory.OpenConnectionAsync();
+
+        const string sql =
+            $"""
+             SELECT
+                 t.id                AS {nameof(TemplateSummaryResponse.Id)},
+                 t.name              AS {nameof(TemplateSummaryResponse.Name)},
+                 t.description       AS {nameof(TemplateSummaryResponse.Description)},
+                 t.tier              AS {nameof(TemplateSummaryResponse.Tier)},
+                 t.preview_image_url AS {nameof(TemplateSummaryResponse.PreviewImageUrl)}
+             FROM catalog.templates t
+             WHERE (@Tier IS NULL OR t.tier = @Tier)
+             ORDER BY t.name ASC
+             """;
+
+        IEnumerable<TemplateSummaryResponse> rows = await connection.QueryAsync<TemplateSummaryResponse>(
+            new CommandDefinition(sql, new { Tier = query.Tier?.ToString() }, cancellationToken: cancellationToken));
+
+        IReadOnlyList<TemplateSummaryResponse> result = [.. rows];
+
+        await cacheService.SetAsync(cacheKey, result, TimeSpan.FromMinutes(30), cancellationToken);
+
+        return Result.Success(result);
+    }
+}
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/GetTemplates/TemplateSummaryResponse.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/GetTemplates/TemplateSummaryResponse.cs
new file mode 100644
index 0000000..ececb74
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/GetTemplates/TemplateSummaryResponse.cs
@@ -0,0 +1,8 @@
+namespace Eternelle.Modules.Catalog.Application.Templates.GetTemplates;
+
+public sealed record TemplateSummaryResponse(
+    Guid Id,
+    string Name,
+    string? Description,
+    string Tier,
+    string? PreviewImageUrl);

From af8134e8b76ee469fdde7458384c43b7342af75c Mon Sep 17 00:00:00 2001
From: Carl Marion <carlmarion.develops@gmail.com>
Date: Wed, 27 May 2026 14:59:37 +0800
Subject: [PATCH 20/31] Eternelle-180 Add GetTemplateById query

---
 .../GetTemplateById/GetTemplateByIdQuery.cs   |   5 +
 .../GetTemplateByIdQueryHandler.cs            | 107 ++++++++++++++++++
 .../GetTemplateById/TemplateDetailResponse.cs |  33 ++++++
 3 files changed, 145 insertions(+)
 create mode 100644 src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/GetTemplateById/GetTemplateByIdQuery.cs
 create mode 100644 src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/GetTemplateById/GetTemplateByIdQueryHandler.cs
 create mode 100644 src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/GetTemplateById/TemplateDetailResponse.cs

diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/GetTemplateById/GetTemplateByIdQuery.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/GetTemplateById/GetTemplateByIdQuery.cs
new file mode 100644
index 0000000..ef46ba7
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/GetTemplateById/GetTemplateByIdQuery.cs
@@ -0,0 +1,5 @@
+using Eternelle.Common.Application.Messaging;
+
+namespace Eternelle.Modules.Catalog.Application.Templates.GetTemplateById;
+
+public sealed record GetTemplateByIdQuery(Guid TemplateId) : IQuery<TemplateDetailResponse>;
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/GetTemplateById/GetTemplateByIdQueryHandler.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/GetTemplateById/GetTemplateByIdQueryHandler.cs
new file mode 100644
index 0000000..f8ea139
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/GetTemplateById/GetTemplateByIdQueryHandler.cs
@@ -0,0 +1,107 @@
+using System.Data.Common;
+using Dapper;
+using Eternelle.Common.Application.Caching;
+using Eternelle.Common.Application.Data;
+using Eternelle.Common.Application.Messaging;
+using Eternelle.Common.Domain;
+using Eternelle.Modules.Catalog.Domain.Templates;
+
+namespace Eternelle.Modules.Catalog.Application.Templates.GetTemplateById;
+
+internal sealed class GetTemplateByIdQueryHandler(
+    IDbConnectionFactory dbConnectionFactory,
+    ICacheService cacheService)
+    : IQueryHandler<GetTemplateByIdQuery, TemplateDetailResponse>
+{
+    public async Task<Result<TemplateDetailResponse>> Handle(
+        GetTemplateByIdQuery query,
+        CancellationToken cancellationToken)
+    {
+        string cacheKey = CatalogCacheKeys.TemplateById(query.TemplateId);
+
+        TemplateDetailResponse? cached =
+            await cacheService.GetAsync<TemplateDetailResponse>(cacheKey, cancellationToken);
+        if (cached is not null)
+        {
+            return Result.Success(cached);
+        }
+
+        await using DbConnection connection = await dbConnectionFactory.OpenConnectionAsync();
+
+        const string headSql =
+            """
+            SELECT id, name, description, tier, preview_image_url
+            FROM catalog.templates
+            WHERE id = @TemplateId
+            """;
+
+        TemplateHeadRow? head = await connection.QuerySingleOrDefaultAsync<TemplateHeadRow>(
+            new CommandDefinition(headSql, new { query.TemplateId }, cancellationToken: cancellationToken));
+
+        if (head is null)
+        {
+            return Result.Failure<TemplateDetailResponse>(
+                TemplateErrors.NotFound(new TemplateId(query.TemplateId)));
+        }
+
+        const string themesSql =
+            $"""
+            SELECT
+                id            AS {nameof(ThemeResponse.Id)},
+                theme_index   AS {nameof(ThemeResponse.ThemeIndex)},
+                name          AS {nameof(ThemeResponse.Name)},
+                colors        AS {nameof(ThemeResponse.ColorsJson)},
+                typography    AS {nameof(ThemeResponse.TypographyJson)},
+                textures      AS {nameof(ThemeResponse.TexturesJson)},
+                is_dark       AS {nameof(ThemeResponse.IsDark)}
+            FROM catalog.template_themes
+            WHERE template_id = @TemplateId
+            ORDER BY theme_index ASC
+            """;
+
+        const string sectionsSql =
+            $"""
+            SELECT
+                id            AS {nameof(SupportedSectionResponse.Id)},
+                section_id    AS {nameof(SupportedSectionResponse.SectionId)},
+                display_order AS {nameof(SupportedSectionResponse.DisplayOrder)}
+            FROM catalog.template_supported_sections
+            WHERE template_id = @TemplateId
+            ORDER BY display_order ASC
+            """;
+
+        const string variantsSql =
+            $"""
+            SELECT
+                id           AS {nameof(SectionVariantResponse.Id)},
+                section_id   AS {nameof(SectionVariantResponse.SectionId)},
+                variant      AS {nameof(SectionVariantResponse.Variant)},
+                is_default   AS {nameof(SectionVariantResponse.IsDefault)},
+                price_class  AS {nameof(SectionVariantResponse.PriceClass)},
+                upload_limit AS {nameof(SectionVariantResponse.UploadLimit)}
+            FROM catalog.template_section_variants
+            WHERE template_id = @TemplateId
+            ORDER BY section_id ASC, variant ASC
+            """;
+
+        object args = new { TemplateId = head.Id };
+
+        IEnumerable<ThemeResponse> themes = await connection.QueryAsync<ThemeResponse>(
+            new CommandDefinition(themesSql, args, cancellationToken: cancellationToken));
+        IEnumerable<SupportedSectionResponse> sections = await connection.QueryAsync<SupportedSectionResponse>(
+            new CommandDefinition(sectionsSql, args, cancellationToken: cancellationToken));
+        IEnumerable<SectionVariantResponse> variants = await connection.QueryAsync<SectionVariantResponse>(
+            new CommandDefinition(variantsSql, args, cancellationToken: cancellationToken));
+
+        var result = new TemplateDetailResponse(
+            head.Id, head.Name, head.Description, head.Tier, head.PreviewImageUrl,
+            [.. themes], [.. sections], [.. variants]);
+
+        await cacheService.SetAsync(cacheKey, result, TimeSpan.FromMinutes(30), cancellationToken);
+
+        return Result.Success(result);
+    }
+
+    private sealed record TemplateHeadRow(
+        Guid Id, string Name, string? Description, string Tier, string? PreviewImageUrl);
+}
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/GetTemplateById/TemplateDetailResponse.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/GetTemplateById/TemplateDetailResponse.cs
new file mode 100644
index 0000000..7e5495d
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/GetTemplateById/TemplateDetailResponse.cs
@@ -0,0 +1,33 @@
+namespace Eternelle.Modules.Catalog.Application.Templates.GetTemplateById;
+
+public sealed record TemplateDetailResponse(
+    Guid Id,
+    string Name,
+    string? Description,
+    string Tier,
+    string? PreviewImageUrl,
+    IReadOnlyList<ThemeResponse> Themes,
+    IReadOnlyList<SupportedSectionResponse> Sections,
+    IReadOnlyList<SectionVariantResponse> Variants);
+
+public sealed record ThemeResponse(
+    Guid Id,
+    int ThemeIndex,
+    string Name,
+    string ColorsJson,
+    string TypographyJson,
+    string? TexturesJson,
+    bool IsDark);
+
+public sealed record SupportedSectionResponse(
+    Guid Id,
+    string SectionId,
+    int DisplayOrder);
+
+public sealed record SectionVariantResponse(
+    Guid Id,
+    string SectionId,
+    string Variant,
+    bool IsDefault,
+    string PriceClass,
+    int? UploadLimit);

From 231b6b5878c9ff4aa8b8a7df6d40aec277b3d092 Mon Sep 17 00:00:00 2001
From: Carl Marion <carlmarion.develops@gmail.com>
Date: Wed, 27 May 2026 15:01:59 +0800
Subject: [PATCH 21/31] Eternelle-180 Add GetSupportedSections and
 GetSectionVariants queries

---
 .../GetSectionVariantsQuery.cs                |  8 ++++
 .../GetSectionVariantsQueryHandler.cs         | 41 +++++++++++++++++++
 .../GetSupportedSectionsQuery.cs              |  7 ++++
 .../GetSupportedSectionsQueryHandler.cs       | 35 ++++++++++++++++
 4 files changed, 91 insertions(+)
 create mode 100644 src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/GetSectionVariants/GetSectionVariantsQuery.cs
 create mode 100644 src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/GetSectionVariants/GetSectionVariantsQueryHandler.cs
 create mode 100644 src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/GetSupportedSections/GetSupportedSectionsQuery.cs
 create mode 100644 src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/GetSupportedSections/GetSupportedSectionsQueryHandler.cs

diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/GetSectionVariants/GetSectionVariantsQuery.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/GetSectionVariants/GetSectionVariantsQuery.cs
new file mode 100644
index 0000000..b5c92f8
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/GetSectionVariants/GetSectionVariantsQuery.cs
@@ -0,0 +1,8 @@
+using Eternelle.Common.Application.Messaging;
+using Eternelle.Modules.Catalog.Application.Templates.GetTemplateById;
+using Eternelle.Modules.Catalog.Domain.Templates;
+
+namespace Eternelle.Modules.Catalog.Application.Templates.GetSectionVariants;
+
+public sealed record GetSectionVariantsQuery(Guid TemplateId, SectionId SectionId)
+    : IQuery<IReadOnlyList<SectionVariantResponse>>;
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/GetSectionVariants/GetSectionVariantsQueryHandler.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/GetSectionVariants/GetSectionVariantsQueryHandler.cs
new file mode 100644
index 0000000..8823201
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/GetSectionVariants/GetSectionVariantsQueryHandler.cs
@@ -0,0 +1,41 @@
+using System.Data.Common;
+using Dapper;
+using Eternelle.Common.Application.Data;
+using Eternelle.Common.Application.Messaging;
+using Eternelle.Common.Domain;
+using Eternelle.Modules.Catalog.Application.Templates.GetTemplateById;
+
+namespace Eternelle.Modules.Catalog.Application.Templates.GetSectionVariants;
+
+internal sealed class GetSectionVariantsQueryHandler(IDbConnectionFactory dbConnectionFactory)
+    : IQueryHandler<GetSectionVariantsQuery, IReadOnlyList<SectionVariantResponse>>
+{
+    public async Task<Result<IReadOnlyList<SectionVariantResponse>>> Handle(
+        GetSectionVariantsQuery query,
+        CancellationToken cancellationToken)
+    {
+        await using DbConnection connection = await dbConnectionFactory.OpenConnectionAsync();
+
+        const string sql =
+            $"""
+            SELECT
+                id           AS {nameof(SectionVariantResponse.Id)},
+                section_id   AS {nameof(SectionVariantResponse.SectionId)},
+                variant      AS {nameof(SectionVariantResponse.Variant)},
+                is_default   AS {nameof(SectionVariantResponse.IsDefault)},
+                price_class  AS {nameof(SectionVariantResponse.PriceClass)},
+                upload_limit AS {nameof(SectionVariantResponse.UploadLimit)}
+            FROM catalog.template_section_variants
+            WHERE template_id = @TemplateId AND section_id = @SectionId
+            ORDER BY variant ASC
+            """;
+
+        IEnumerable<SectionVariantResponse> rows = await connection.QueryAsync<SectionVariantResponse>(
+            new CommandDefinition(
+                sql,
+                new { query.TemplateId, SectionId = query.SectionId.ToString() },
+                cancellationToken: cancellationToken));
+
+        return Result.Success<IReadOnlyList<SectionVariantResponse>>([.. rows]);
+    }
+}
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/GetSupportedSections/GetSupportedSectionsQuery.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/GetSupportedSections/GetSupportedSectionsQuery.cs
new file mode 100644
index 0000000..1481e10
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/GetSupportedSections/GetSupportedSectionsQuery.cs
@@ -0,0 +1,7 @@
+using Eternelle.Common.Application.Messaging;
+using Eternelle.Modules.Catalog.Application.Templates.GetTemplateById;
+
+namespace Eternelle.Modules.Catalog.Application.Templates.GetSupportedSections;
+
+public sealed record GetSupportedSectionsQuery(Guid TemplateId)
+    : IQuery<IReadOnlyList<SupportedSectionResponse>>;
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/GetSupportedSections/GetSupportedSectionsQueryHandler.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/GetSupportedSections/GetSupportedSectionsQueryHandler.cs
new file mode 100644
index 0000000..cd09b42
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/GetSupportedSections/GetSupportedSectionsQueryHandler.cs
@@ -0,0 +1,35 @@
+using System.Data.Common;
+using Dapper;
+using Eternelle.Common.Application.Data;
+using Eternelle.Common.Application.Messaging;
+using Eternelle.Common.Domain;
+using Eternelle.Modules.Catalog.Application.Templates.GetTemplateById;
+
+namespace Eternelle.Modules.Catalog.Application.Templates.GetSupportedSections;
+
+internal sealed class GetSupportedSectionsQueryHandler(IDbConnectionFactory dbConnectionFactory)
+    : IQueryHandler<GetSupportedSectionsQuery, IReadOnlyList<SupportedSectionResponse>>
+{
+    public async Task<Result<IReadOnlyList<SupportedSectionResponse>>> Handle(
+        GetSupportedSectionsQuery query,
+        CancellationToken cancellationToken)
+    {
+        await using DbConnection connection = await dbConnectionFactory.OpenConnectionAsync();
+
+        const string sql =
+            $"""
+            SELECT
+                id            AS {nameof(SupportedSectionResponse.Id)},
+                section_id    AS {nameof(SupportedSectionResponse.SectionId)},
+                display_order AS {nameof(SupportedSectionResponse.DisplayOrder)}
+            FROM catalog.template_supported_sections
+            WHERE template_id = @TemplateId
+            ORDER BY display_order ASC
+            """;
+
+        IEnumerable<SupportedSectionResponse> rows = await connection.QueryAsync<SupportedSectionResponse>(
+            new CommandDefinition(sql, new { query.TemplateId }, cancellationToken: cancellationToken));
+
+        return Result.Success<IReadOnlyList<SupportedSectionResponse>>([.. rows]);
+    }
+}

From e7f88eea4076b282a68bd3d5622b2293cbb1281c Mon Sep 17 00:00:00 2001
From: Carl Marion <carlmarion.develops@gmail.com>
Date: Wed, 27 May 2026 16:50:18 +0800
Subject: [PATCH 22/31] Eternelle-180 Add CatalogDbContext, id converters, and
 entity configurations

Adds InternalsVisibleTo for the Infrastructure layer to access VO FromPersistence()
methods, plus EF Core entity type configurations for all Template aggregates.
---
 .../AssemblyInfo.cs                           |  6 ++
 .../Database/CatalogDbContext.cs              | 35 +++++++++++
 .../Converters/TemplateIdConverter.cs         |  7 +++
 .../TemplateSectionVariantIdConverter.cs      |  7 +++
 .../TemplateSupportedSectionIdConverter.cs    |  7 +++
 .../Converters/TemplateThemeIdConverter.cs    |  7 +++
 .../Templates/TemplateConfiguration.cs        | 63 +++++++++++++++++++
 .../TemplateSectionVariantConfiguration.cs    | 41 ++++++++++++
 .../TemplateSupportedSectionConfiguration.cs  | 27 ++++++++
 .../Templates/TemplateThemeConfiguration.cs   | 49 +++++++++++++++
 10 files changed, 249 insertions(+)
 create mode 100644 src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/AssemblyInfo.cs
 create mode 100644 src/Modules/Catalog/Eternelle.Modules.Catalog.Infrastructure/Database/CatalogDbContext.cs
 create mode 100644 src/Modules/Catalog/Eternelle.Modules.Catalog.Infrastructure/Database/Converters/TemplateIdConverter.cs
 create mode 100644 src/Modules/Catalog/Eternelle.Modules.Catalog.Infrastructure/Database/Converters/TemplateSectionVariantIdConverter.cs
 create mode 100644 src/Modules/Catalog/Eternelle.Modules.Catalog.Infrastructure/Database/Converters/TemplateSupportedSectionIdConverter.cs
 create mode 100644 src/Modules/Catalog/Eternelle.Modules.Catalog.Infrastructure/Database/Converters/TemplateThemeIdConverter.cs
 create mode 100644 src/Modules/Catalog/Eternelle.Modules.Catalog.Infrastructure/Templates/TemplateConfiguration.cs
 create mode 100644 src/Modules/Catalog/Eternelle.Modules.Catalog.Infrastructure/Templates/TemplateSectionVariantConfiguration.cs
 create mode 100644 src/Modules/Catalog/Eternelle.Modules.Catalog.Infrastructure/Templates/TemplateSupportedSectionConfiguration.cs
 create mode 100644 src/Modules/Catalog/Eternelle.Modules.Catalog.Infrastructure/Templates/TemplateThemeConfiguration.cs

diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/AssemblyInfo.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/AssemblyInfo.cs
new file mode 100644
index 0000000..34b942b
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/AssemblyInfo.cs
@@ -0,0 +1,6 @@
+using System.Runtime.CompilerServices;
+
+// Allow the Infrastructure layer to access internal members — specifically
+// FromPersistence() factory methods on value objects, which bypass Create()
+// validation for values that were already validated on write.
+[assembly: InternalsVisibleTo("Eternelle.Modules.Catalog.Infrastructure")]
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Infrastructure/Database/CatalogDbContext.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Infrastructure/Database/CatalogDbContext.cs
new file mode 100644
index 0000000..7df1f75
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Infrastructure/Database/CatalogDbContext.cs
@@ -0,0 +1,35 @@
+using Eternelle.Common.Infrastructure.Outbox;
+using Eternelle.Modules.Catalog.Application.Abstractions.Data;
+using Eternelle.Modules.Catalog.Domain.Templates;
+using Eternelle.Modules.Catalog.Infrastructure.Database.Converters;
+using Eternelle.Modules.Catalog.Infrastructure.Templates;
+using Microsoft.EntityFrameworkCore;
+
+namespace Eternelle.Modules.Catalog.Infrastructure.Database;
+
+public sealed class CatalogDbContext(DbContextOptions<CatalogDbContext> options)
+    : DbContext(options), IUnitOfWork
+{
+    internal DbSet<Template> Templates { get; set; }
+
+    protected override void ConfigureConventions(ModelConfigurationBuilder configurationBuilder)
+    {
+        configurationBuilder.Properties<TemplateId>().HaveConversion<TemplateIdConverter>();
+        configurationBuilder.Properties<TemplateThemeId>().HaveConversion<TemplateThemeIdConverter>();
+        configurationBuilder.Properties<TemplateSupportedSectionId>().HaveConversion<TemplateSupportedSectionIdConverter>();
+        configurationBuilder.Properties<TemplateSectionVariantId>().HaveConversion<TemplateSectionVariantIdConverter>();
+    }
+
+    protected override void OnModelCreating(ModelBuilder modelBuilder)
+    {
+        modelBuilder.HasDefaultSchema(Schemas.Catalog);
+
+        modelBuilder.ApplyConfiguration(new OutboxMessageConfiguration());
+        modelBuilder.ApplyConfiguration(new OutboxMessageConsumerConfiguration());
+
+        modelBuilder.ApplyConfiguration(new TemplateConfiguration());
+        modelBuilder.ApplyConfiguration(new TemplateThemeConfiguration());
+        modelBuilder.ApplyConfiguration(new TemplateSupportedSectionConfiguration());
+        modelBuilder.ApplyConfiguration(new TemplateSectionVariantConfiguration());
+    }
+}
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Infrastructure/Database/Converters/TemplateIdConverter.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Infrastructure/Database/Converters/TemplateIdConverter.cs
new file mode 100644
index 0000000..8bf1b1d
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Infrastructure/Database/Converters/TemplateIdConverter.cs
@@ -0,0 +1,7 @@
+using Eternelle.Modules.Catalog.Domain.Templates;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+
+namespace Eternelle.Modules.Catalog.Infrastructure.Database.Converters;
+
+internal sealed class TemplateIdConverter()
+    : ValueConverter<TemplateId, Guid>(id => id.Value, value => new TemplateId(value));
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Infrastructure/Database/Converters/TemplateSectionVariantIdConverter.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Infrastructure/Database/Converters/TemplateSectionVariantIdConverter.cs
new file mode 100644
index 0000000..0ee72b9
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Infrastructure/Database/Converters/TemplateSectionVariantIdConverter.cs
@@ -0,0 +1,7 @@
+using Eternelle.Modules.Catalog.Domain.Templates;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+
+namespace Eternelle.Modules.Catalog.Infrastructure.Database.Converters;
+
+internal sealed class TemplateSectionVariantIdConverter()
+    : ValueConverter<TemplateSectionVariantId, Guid>(id => id.Value, value => new TemplateSectionVariantId(value));
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Infrastructure/Database/Converters/TemplateSupportedSectionIdConverter.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Infrastructure/Database/Converters/TemplateSupportedSectionIdConverter.cs
new file mode 100644
index 0000000..bded9a7
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Infrastructure/Database/Converters/TemplateSupportedSectionIdConverter.cs
@@ -0,0 +1,7 @@
+using Eternelle.Modules.Catalog.Domain.Templates;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+
+namespace Eternelle.Modules.Catalog.Infrastructure.Database.Converters;
+
+internal sealed class TemplateSupportedSectionIdConverter()
+    : ValueConverter<TemplateSupportedSectionId, Guid>(id => id.Value, value => new TemplateSupportedSectionId(value));
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Infrastructure/Database/Converters/TemplateThemeIdConverter.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Infrastructure/Database/Converters/TemplateThemeIdConverter.cs
new file mode 100644
index 0000000..394e2a1
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Infrastructure/Database/Converters/TemplateThemeIdConverter.cs
@@ -0,0 +1,7 @@
+using Eternelle.Modules.Catalog.Domain.Templates;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+
+namespace Eternelle.Modules.Catalog.Infrastructure.Database.Converters;
+
+internal sealed class TemplateThemeIdConverter()
+    : ValueConverter<TemplateThemeId, Guid>(id => id.Value, value => new TemplateThemeId(value));
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Infrastructure/Templates/TemplateConfiguration.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Infrastructure/Templates/TemplateConfiguration.cs
new file mode 100644
index 0000000..18fac0e
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Infrastructure/Templates/TemplateConfiguration.cs
@@ -0,0 +1,63 @@
+using System.Text.Json;
+using Eternelle.Modules.Catalog.Domain.Shared;
+using Eternelle.Modules.Catalog.Domain.Templates;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.ChangeTracking;
+using Microsoft.EntityFrameworkCore.Metadata.Builders;
+
+namespace Eternelle.Modules.Catalog.Infrastructure.Templates;
+
+internal sealed class TemplateConfiguration : IEntityTypeConfiguration<Template>
+{
+    public void Configure(EntityTypeBuilder<Template> builder)
+    {
+        builder.ToTable("templates");
+        builder.HasKey(t => t.Id);
+
+        builder.Property(t => t.Name)
+            .HasConversion(v => v.Value, v => TemplateName.FromPersistence(v))
+            .IsRequired()
+            .HasMaxLength(TemplateName.MaxLength);
+
+        builder.HasIndex(t => t.Name).IsUnique().HasDatabaseName("ix_templates_name");
+
+        builder.Property(t => t.Description)
+            .HasConversion(
+                v => v == null ? null : v.Value,
+                v => v == null ? null : TemplateDescription.FromPersistence(v))
+            .HasMaxLength(TemplateDescription.MaxLength);
+
+        builder.Property(t => t.Tier)
+            .HasConversion<string>()
+            .IsRequired();
+
+        builder.Property(t => t.PreviewImageUrl)
+            .HasConversion(
+                v => v == null ? null : v.Value,
+                v => v == null ? null : ImageUrl.FromPersistence(v))
+            .HasMaxLength(ImageUrl.MaxLength);
+
+        var featuresComparer = new ValueComparer<IReadOnlyList<string>>(
+            (a, b) => a!.SequenceEqual(b!),
+            v => v.Aggregate(0, (hash, item) => HashCode.Combine(hash, item.GetHashCode())),
+            v => v.ToList());
+
+        builder.Property(t => t.Features)
+            .HasColumnType("jsonb")
+            .HasConversion(
+                v => JsonSerializer.Serialize(v, (JsonSerializerOptions?)null),
+                v => JsonSerializer.Deserialize<List<string>>(v, (JsonSerializerOptions?)null) ?? new List<string>())
+            .Metadata.SetValueComparer(featuresComparer);
+
+        builder.Property(t => t.CreatedAtUtc).IsRequired();
+        builder.Property(t => t.UpdatedAtUtc).IsRequired();
+
+        builder.HasMany(t => t.Themes).WithOne().HasForeignKey(x => x.TemplateId).OnDelete(DeleteBehavior.Cascade);
+        builder.HasMany(t => t.SupportedSections).WithOne().HasForeignKey(x => x.TemplateId).OnDelete(DeleteBehavior.Cascade);
+        builder.HasMany(t => t.SectionVariants).WithOne().HasForeignKey(x => x.TemplateId).OnDelete(DeleteBehavior.Cascade);
+
+        builder.Metadata.FindNavigation(nameof(Template.Themes))!.SetPropertyAccessMode(PropertyAccessMode.Field);
+        builder.Metadata.FindNavigation(nameof(Template.SupportedSections))!.SetPropertyAccessMode(PropertyAccessMode.Field);
+        builder.Metadata.FindNavigation(nameof(Template.SectionVariants))!.SetPropertyAccessMode(PropertyAccessMode.Field);
+    }
+}
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Infrastructure/Templates/TemplateSectionVariantConfiguration.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Infrastructure/Templates/TemplateSectionVariantConfiguration.cs
new file mode 100644
index 0000000..c285e95
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Infrastructure/Templates/TemplateSectionVariantConfiguration.cs
@@ -0,0 +1,41 @@
+using Eternelle.Modules.Catalog.Domain.Templates;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Metadata.Builders;
+
+namespace Eternelle.Modules.Catalog.Infrastructure.Templates;
+
+internal sealed class TemplateSectionVariantConfiguration : IEntityTypeConfiguration<TemplateSectionVariant>
+{
+    public void Configure(EntityTypeBuilder<TemplateSectionVariant> builder)
+    {
+        builder.ToTable("template_section_variants");
+        builder.HasKey(v => v.Id);
+
+        builder.Property(v => v.TemplateId).IsRequired();
+
+        builder.Property(v => v.SectionId)
+            .HasConversion<string>()
+            .IsRequired()
+            .HasMaxLength(50);
+
+        builder.Property(v => v.Variant).IsRequired().HasMaxLength(100);
+
+        builder.Property(v => v.IsDefault).IsRequired();
+
+        builder.Property(v => v.PriceClass)
+            .HasConversion<string>()
+            .IsRequired()
+            .HasMaxLength(50);
+
+        builder.Property(v => v.UploadLimit);
+
+        builder.HasIndex(v => new { v.TemplateId, v.SectionId, v.Variant })
+            .IsUnique()
+            .HasDatabaseName("ix_template_section_variants_template_id_section_id_variant");
+
+        builder.HasIndex(v => new { v.TemplateId, v.SectionId })
+            .IsUnique()
+            .HasFilter("is_default = true")
+            .HasDatabaseName("ux_template_section_variants_one_default");
+    }
+}
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Infrastructure/Templates/TemplateSupportedSectionConfiguration.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Infrastructure/Templates/TemplateSupportedSectionConfiguration.cs
new file mode 100644
index 0000000..d2b0efd
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Infrastructure/Templates/TemplateSupportedSectionConfiguration.cs
@@ -0,0 +1,27 @@
+using Eternelle.Modules.Catalog.Domain.Templates;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Metadata.Builders;
+
+namespace Eternelle.Modules.Catalog.Infrastructure.Templates;
+
+internal sealed class TemplateSupportedSectionConfiguration : IEntityTypeConfiguration<TemplateSupportedSection>
+{
+    public void Configure(EntityTypeBuilder<TemplateSupportedSection> builder)
+    {
+        builder.ToTable("template_supported_sections");
+        builder.HasKey(s => s.Id);
+
+        builder.Property(s => s.TemplateId).IsRequired();
+
+        builder.Property(s => s.SectionId)
+            .HasConversion<string>()
+            .IsRequired()
+            .HasMaxLength(50);
+
+        builder.Property(s => s.DisplayOrder).IsRequired();
+
+        builder.HasIndex(s => new { s.TemplateId, s.SectionId })
+            .IsUnique()
+            .HasDatabaseName("ix_template_supported_sections_template_id_section_id");
+    }
+}
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Infrastructure/Templates/TemplateThemeConfiguration.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Infrastructure/Templates/TemplateThemeConfiguration.cs
new file mode 100644
index 0000000..c0f08dd
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Infrastructure/Templates/TemplateThemeConfiguration.cs
@@ -0,0 +1,49 @@
+using System.Text.Json;
+using Eternelle.Modules.Catalog.Domain.Templates;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Metadata.Builders;
+
+namespace Eternelle.Modules.Catalog.Infrastructure.Templates;
+
+internal sealed class TemplateThemeConfiguration : IEntityTypeConfiguration<TemplateTheme>
+{
+    public void Configure(EntityTypeBuilder<TemplateTheme> builder)
+    {
+        builder.ToTable("template_themes");
+        builder.HasKey(t => t.Id);
+
+        builder.Property(t => t.TemplateId).IsRequired();
+        builder.Property(t => t.ThemeIndex).IsRequired();
+
+        builder.Property(t => t.Name)
+            .HasConversion(v => v.Value, v => TemplateThemeName.FromPersistence(v))
+            .IsRequired()
+            .HasMaxLength(TemplateThemeName.MaxLength);
+
+        builder.Property(t => t.Colors)
+            .HasColumnType("jsonb")
+            .HasConversion(
+                v => JsonSerializer.Serialize(v, (JsonSerializerOptions?)null),
+                v => JsonSerializer.Deserialize<ThemeColors>(v, (JsonSerializerOptions?)null)!)
+            .IsRequired();
+
+        builder.Property(t => t.Typography)
+            .HasColumnType("jsonb")
+            .HasConversion(
+                v => JsonSerializer.Serialize(v, (JsonSerializerOptions?)null),
+                v => JsonSerializer.Deserialize<ThemeTypography>(v, (JsonSerializerOptions?)null)!)
+            .IsRequired();
+
+        builder.Property(t => t.Textures)
+            .HasColumnType("jsonb")
+            .HasConversion(
+                v => v != null ? JsonSerializer.Serialize(v, (JsonSerializerOptions?)null) : null,
+                v => v != null ? JsonSerializer.Deserialize<ThemeTextures>(v, (JsonSerializerOptions?)null) : null);
+
+        builder.Property(t => t.IsDark).IsRequired();
+
+        builder.HasIndex(t => new { t.TemplateId, t.ThemeIndex })
+            .IsUnique()
+            .HasDatabaseName("ix_template_themes_template_id_theme_index");
+    }
+}

From e4d23ee1de05b56bf322ea0c55c2ea6486c23689 Mon Sep 17 00:00:00 2001
From: Carl Marion <carlmarion.develops@gmail.com>
Date: Wed, 27 May 2026 16:52:05 +0800
Subject: [PATCH 23/31] Eternelle-180 Add TemplateRepository

---
 .../Templates/TemplateRepository.cs           | 22 +++++++++++++++++++
 1 file changed, 22 insertions(+)
 create mode 100644 src/Modules/Catalog/Eternelle.Modules.Catalog.Infrastructure/Templates/TemplateRepository.cs

diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Infrastructure/Templates/TemplateRepository.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Infrastructure/Templates/TemplateRepository.cs
new file mode 100644
index 0000000..0aea752
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Infrastructure/Templates/TemplateRepository.cs
@@ -0,0 +1,22 @@
+using Eternelle.Modules.Catalog.Domain.Templates;
+using Eternelle.Modules.Catalog.Infrastructure.Database;
+using Microsoft.EntityFrameworkCore;
+
+namespace Eternelle.Modules.Catalog.Infrastructure.Templates;
+
+internal sealed class TemplateRepository(CatalogDbContext context) : ITemplateRepository
+{
+    public async Task<Template?> GetAsync(TemplateId id, CancellationToken cancellationToken = default) =>
+        await context.Templates
+            .Include(t => t.Themes)
+            .Include(t => t.SupportedSections)
+            .Include(t => t.SectionVariants)
+            .FirstOrDefaultAsync(t => t.Id == id, cancellationToken);
+
+    public async Task<bool> NameExistsAsync(string name, CancellationToken cancellationToken = default) =>
+        await context.Templates.AnyAsync(t => t.Name == TemplateName.FromPersistence(name), cancellationToken);
+
+    public void Insert(Template template) => context.Templates.Add(template);
+
+    public void Update(Template template) => context.Templates.Update(template);
+}

From bf5d704d2455715b3d0fe3522a94a5b78ca9bfef Mon Sep 17 00:00:00 2001
From: Carl Marion <carlmarion.develops@gmail.com>
Date: Wed, 27 May 2026 16:54:48 +0800
Subject: [PATCH 24/31] Eternelle-180 Add outbox plumbing and CatalogModule DI

---
 .../CatalogModule.cs                          |  78 ++++++++++
 .../Outbox/ConfigureProcessOutboxJob.cs       |  29 ++++
 .../Outbox/IdempotentDomainEventHandler.cs    |  62 ++++++++
 .../Outbox/OutboxOptions.cs                   |   7 +
 .../Outbox/ProcessOutboxJob.cs                | 144 ++++++++++++++++++
 5 files changed, 320 insertions(+)
 create mode 100644 src/Modules/Catalog/Eternelle.Modules.Catalog.Infrastructure/CatalogModule.cs
 create mode 100644 src/Modules/Catalog/Eternelle.Modules.Catalog.Infrastructure/Outbox/ConfigureProcessOutboxJob.cs
 create mode 100644 src/Modules/Catalog/Eternelle.Modules.Catalog.Infrastructure/Outbox/IdempotentDomainEventHandler.cs
 create mode 100644 src/Modules/Catalog/Eternelle.Modules.Catalog.Infrastructure/Outbox/OutboxOptions.cs
 create mode 100644 src/Modules/Catalog/Eternelle.Modules.Catalog.Infrastructure/Outbox/ProcessOutboxJob.cs

diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Infrastructure/CatalogModule.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Infrastructure/CatalogModule.cs
new file mode 100644
index 0000000..0bbbffd
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Infrastructure/CatalogModule.cs
@@ -0,0 +1,78 @@
+using Eternelle.Common.Application.Messaging;
+using Eternelle.Common.Infrastructure.Outbox;
+using Eternelle.Common.Presentation.Endpoints;
+using Eternelle.Modules.Catalog.Application.Abstractions.Data;
+using Eternelle.Modules.Catalog.Domain.Templates;
+using Eternelle.Modules.Catalog.Infrastructure.Database;
+using Eternelle.Modules.Catalog.Infrastructure.Outbox;
+using Eternelle.Modules.Catalog.Infrastructure.Templates;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.DependencyInjection.Extensions;
+
+namespace Eternelle.Modules.Catalog.Infrastructure;
+
+public static class CatalogModule
+{
+    public static IServiceCollection AddCatalogModule(
+        this IServiceCollection services,
+        IConfiguration configuration)
+    {
+        services.AddDomainEventHandlers();
+
+        services.AddInfrastructure(configuration);
+
+        services.AddEndpoints(Presentation.AssemblyReference.Assembly);
+
+        return services;
+    }
+
+    private static void AddInfrastructure(this IServiceCollection services, IConfiguration configuration)
+    {
+        services.AddDbContext<CatalogDbContext>((sp, options) =>
+            options
+                .UseNpgsql(
+                    configuration.GetConnectionString("Database"),
+                    npgsqlOptions => npgsqlOptions
+                        .MigrationsHistoryTable(HistoryRepository.DefaultTableName, Schemas.Catalog))
+                .UseSnakeCaseNamingConvention()
+                .AddInterceptors(sp.GetRequiredService<InsertOutboxMessagesInterceptor>()));
+
+        services.AddScoped<IUnitOfWork>(sp => sp.GetRequiredService<CatalogDbContext>());
+
+        services.AddScoped<ITemplateRepository, TemplateRepository>();
+
+        services.AddOptions<OutboxOptions>()
+            .Bind(configuration.GetSection("Catalog:Outbox"))
+            .Validate(o => o.IntervalInSeconds > 0 && o.BatchSize > 0,
+                "Catalog:Outbox: IntervalInSeconds and BatchSize must be greater than 0.")
+            .ValidateOnStart();
+
+        services.ConfigureOptions<ConfigureProcessOutboxJob>();
+    }
+
+    private static void AddDomainEventHandlers(this IServiceCollection services)
+    {
+        Type[] domainEventHandlers = Application.AssemblyReference.Assembly
+            .GetTypes()
+            .Where(t => t.IsAssignableTo(typeof(IDomainEventHandler)))
+            .ToArray();
+
+        foreach (Type domainEventHandler in domainEventHandlers)
+        {
+            services.TryAddScoped(domainEventHandler);
+
+            Type domainEvent = domainEventHandler
+                .GetInterfaces()
+                .Single(i => i.IsGenericType && i.GetGenericTypeDefinition() == typeof(IDomainEventHandler<>))
+                .GetGenericArguments()
+                .Single();
+
+            Type closedIdempotentHandler = typeof(IdempotentDomainEventHandler<>).MakeGenericType(domainEvent);
+
+            services.Decorate(domainEventHandler, closedIdempotentHandler);
+        }
+    }
+}
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Infrastructure/Outbox/ConfigureProcessOutboxJob.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Infrastructure/Outbox/ConfigureProcessOutboxJob.cs
new file mode 100644
index 0000000..733c950
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Infrastructure/Outbox/ConfigureProcessOutboxJob.cs
@@ -0,0 +1,29 @@
+using Microsoft.Extensions.Options;
+using Quartz;
+
+namespace Eternelle.Modules.Catalog.Infrastructure.Outbox;
+
+internal sealed class ConfigureProcessOutboxJob(IOptions<OutboxOptions> outboxOptions)
+    : IConfigureOptions<QuartzOptions>
+{
+    private readonly OutboxOptions _outboxOptions = outboxOptions.Value;
+
+    public void Configure(QuartzOptions options)
+    {
+        if (_outboxOptions.IntervalInSeconds <= 0)
+        {
+            throw new InvalidOperationException(
+                $"Catalog:Outbox:IntervalInSeconds must be a positive integer. Current value: {_outboxOptions.IntervalInSeconds}");
+        }
+
+        string jobName = typeof(ProcessOutboxJob).FullName!;
+
+        options
+            .AddJob<ProcessOutboxJob>(configure => configure.WithIdentity(jobName))
+            .AddTrigger(configure =>
+                configure
+                    .ForJob(jobName)
+                    .WithSimpleSchedule(schedule =>
+                        schedule.WithIntervalInSeconds(_outboxOptions.IntervalInSeconds).RepeatForever()));
+    }
+}
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Infrastructure/Outbox/IdempotentDomainEventHandler.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Infrastructure/Outbox/IdempotentDomainEventHandler.cs
new file mode 100644
index 0000000..84fc61e
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Infrastructure/Outbox/IdempotentDomainEventHandler.cs
@@ -0,0 +1,62 @@
+using System.Data.Common;
+using Dapper;
+using Eternelle.Common.Application.Data;
+using Eternelle.Common.Application.Messaging;
+using Eternelle.Common.Domain;
+using Eternelle.Common.Infrastructure.Outbox;
+using Eternelle.Modules.Catalog.Infrastructure.Database;
+
+namespace Eternelle.Modules.Catalog.Infrastructure.Outbox;
+
+internal sealed class IdempotentDomainEventHandler<TDomainEvent>(
+    IDomainEventHandler<TDomainEvent> decorated,
+    IDbConnectionFactory dbConnectionFactory)
+    : DomainEventHandler<TDomainEvent>
+    where TDomainEvent : IDomainEvent
+{
+    public override async Task Handle(TDomainEvent domainEvent, CancellationToken cancellationToken = default)
+    {
+        await using DbConnection connection = await dbConnectionFactory.OpenConnectionAsync();
+
+        var outboxMessageConsumer = new OutboxMessageConsumer(domainEvent.Id, decorated.GetType().Name);
+
+        if (await OutboxConsumerExistsAsync(connection, outboxMessageConsumer))
+        {
+            return;
+        }
+
+        await decorated.Handle(domainEvent, cancellationToken);
+
+        await InsertOutboxConsumerAsync(connection, outboxMessageConsumer);
+    }
+
+    private static async Task<bool> OutboxConsumerExistsAsync(
+        DbConnection dbConnection,
+        OutboxMessageConsumer outboxMessageConsumer)
+    {
+        const string sql =
+            $"""
+            SELECT EXISTS(
+                SELECT 1
+                FROM {Schemas.Catalog}.outbox_message_consumers
+                WHERE outbox_message_id = @OutboxMessageId AND
+                      name = @Name
+            )
+            """;
+
+        return await dbConnection.ExecuteScalarAsync<bool>(sql, outboxMessageConsumer);
+    }
+
+    private static async Task InsertOutboxConsumerAsync(
+        DbConnection dbConnection,
+        OutboxMessageConsumer outboxMessageConsumer)
+    {
+        const string sql =
+            $"""
+            INSERT INTO {Schemas.Catalog}.outbox_message_consumers(outbox_message_id, name)
+            VALUES (@OutboxMessageId, @Name)
+            """;
+
+        await dbConnection.ExecuteAsync(sql, outboxMessageConsumer);
+    }
+}
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Infrastructure/Outbox/OutboxOptions.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Infrastructure/Outbox/OutboxOptions.cs
new file mode 100644
index 0000000..e682248
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Infrastructure/Outbox/OutboxOptions.cs
@@ -0,0 +1,7 @@
+namespace Eternelle.Modules.Catalog.Infrastructure.Outbox;
+
+internal sealed class OutboxOptions
+{
+    public int IntervalInSeconds { get; init; }
+    public int BatchSize { get; init; }
+}
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Infrastructure/Outbox/ProcessOutboxJob.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Infrastructure/Outbox/ProcessOutboxJob.cs
new file mode 100644
index 0000000..4971840
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Infrastructure/Outbox/ProcessOutboxJob.cs
@@ -0,0 +1,144 @@
+using System.Data;
+using System.Data.Common;
+using Dapper;
+using Eternelle.Common.Application.Clock;
+using Eternelle.Common.Application.Data;
+using Eternelle.Common.Application.Messaging;
+using Eternelle.Common.Domain;
+using Eternelle.Common.Infrastructure.Outbox;
+using Eternelle.Common.Infrastructure.Serialization;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Options;
+using Newtonsoft.Json;
+using Quartz;
+
+namespace Eternelle.Modules.Catalog.Infrastructure.Outbox;
+
+[DisallowConcurrentExecution]
+internal sealed partial class ProcessOutboxJob(
+    IDbConnectionFactory dbConnectionFactory,
+    IServiceScopeFactory serviceScopeFactory,
+    IDateTimeProvider dateTimeProvider,
+    IOptions<OutboxOptions> outboxOptions,
+    ILogger<ProcessOutboxJob> logger) : IJob
+{
+    private const string ModuleName = "Catalog";
+
+    public async Task Execute(IJobExecutionContext context)
+    {
+        LogBeginProcessing(logger, ModuleName);
+
+        await using DbConnection connection = await dbConnectionFactory.OpenConnectionAsync();
+        await using DbTransaction transaction = await connection.BeginTransactionAsync();
+
+        IReadOnlyList<OutboxMessageResponse> outboxMessages = await GetOutboxMessagesAsync(connection, transaction);
+
+        foreach (OutboxMessageResponse outboxMessage in outboxMessages)
+        {
+            Exception? exception = null;
+
+            try
+            {
+                IDomainEvent domainEvent = JsonConvert.DeserializeObject<IDomainEvent>(
+                    outboxMessage.Content,
+                    SerializerSettings.Instance)!;
+
+                using IServiceScope scope = serviceScopeFactory.CreateScope();
+
+                IEnumerable<IDomainEventHandler> handlers = DomainEventHandlersFactory.GetHandlers(
+                    domainEvent.GetType(),
+                    scope.ServiceProvider,
+                    Application.AssemblyReference.Assembly);
+
+                foreach (IDomainEventHandler domainEventHandler in handlers)
+                {
+                    await domainEventHandler.Handle(domainEvent, context.CancellationToken);
+                }
+            }
+            catch (Exception caughtException)
+            {
+                LogProcessingError(logger, caughtException, ModuleName, outboxMessage.Id);
+
+                exception = caughtException;
+            }
+
+            await UpdateOutboxMessageAsync(connection, transaction, outboxMessage, exception);
+        }
+
+        await transaction.CommitAsync();
+
+        LogCompleted(logger, ModuleName);
+    }
+
+    private async Task<IReadOnlyList<OutboxMessageResponse>> GetOutboxMessagesAsync(
+        IDbConnection connection,
+        IDbTransaction transaction)
+    {
+        string sql =
+            $"""
+             SELECT
+                id AS {nameof(OutboxMessageResponse.Id)},
+                content AS {nameof(OutboxMessageResponse.Content)}
+             FROM catalog.outbox_messages
+             WHERE processed_on_utc IS NULL
+             ORDER BY occurred_on_utc
+             LIMIT {outboxOptions.Value.BatchSize}
+             FOR UPDATE SKIP LOCKED
+             """;
+
+        IEnumerable<OutboxMessageResponse> outboxMessages = await connection.QueryAsync<OutboxMessageResponse>(
+            sql,
+            transaction: transaction);
+
+        return outboxMessages.ToList();
+    }
+
+    private async Task UpdateOutboxMessageAsync(
+        IDbConnection connection,
+        IDbTransaction transaction,
+        OutboxMessageResponse outboxMessage,
+        Exception? exception)
+    {
+        if (exception is null)
+        {
+            const string sql =
+                """
+                UPDATE catalog.outbox_messages
+                SET processed_on_utc = @ProcessedOnUtc,
+                    error = NULL
+                WHERE id = @Id
+                """;
+
+            await connection.ExecuteAsync(
+                sql,
+                new { outboxMessage.Id, ProcessedOnUtc = dateTimeProvider.UtcNow },
+                transaction: transaction);
+        }
+        else
+        {
+            const string sql =
+                """
+                UPDATE catalog.outbox_messages
+                SET error = @Error
+                WHERE id = @Id
+                """;
+
+            await connection.ExecuteAsync(
+                sql,
+                new { outboxMessage.Id, Error = exception.ToString() },
+                transaction: transaction);
+        }
+    }
+
+    internal sealed record OutboxMessageResponse(Guid Id, string Content);
+
+    [LoggerMessage(LogLevel.Information, "{module} - Beginning to process outbox messages")]
+    private static partial void LogBeginProcessing(ILogger logger, string module);
+
+    [LoggerMessage(LogLevel.Information, "{module} - Completed processing outbox messages")]
+    private static partial void LogCompleted(ILogger logger, string module);
+
+    [LoggerMessage(LogLevel.Error, "{module} - Exception while processing outbox message {messageId}")]
+    private static partial void LogProcessingError(ILogger logger, Exception exception, string module, Guid messageId);
+}

From 70bf5ea8f62d1042aa287a9c250a0b56b52c0b7b Mon Sep 17 00:00:00 2001
From: Carl Marion <carlmarion.develops@gmail.com>
Date: Wed, 27 May 2026 17:25:04 +0800
Subject: [PATCH 25/31] Eternelle-180 Add presentation layer endpoints (Tasks
 26-27)

Public read endpoints (GetTemplates, GetTemplateById, GetSectionVariants) with AllowAnonymous; admin write endpoints (CreateTemplate, UpdateTemplate, AddTemplateTheme, AddSupportedSection, AddSectionVariant) gated behind catalog:manage policy.
---
 .../Tags.cs                                   |  6 +++
 .../Templates/AddSectionVariantEndpoint.cs    | 36 ++++++++++++++++
 .../Templates/AddSupportedSectionEndpoint.cs  | 34 +++++++++++++++
 .../Templates/AddTemplateThemeEndpoint.cs     | 41 +++++++++++++++++++
 .../Templates/CreateTemplateEndpoint.cs       | 41 +++++++++++++++++++
 .../Templates/GetSectionVariantsEndpoint.cs   | 32 +++++++++++++++
 .../Templates/GetTemplateByIdEndpoint.cs      | 29 +++++++++++++
 .../Templates/GetTemplatesEndpoint.cs         | 30 ++++++++++++++
 .../Templates/UpdateTemplateEndpoint.cs       | 38 +++++++++++++++++
 9 files changed, 287 insertions(+)
 create mode 100644 src/Modules/Catalog/Eternelle.Modules.Catalog.Presentation/Tags.cs
 create mode 100644 src/Modules/Catalog/Eternelle.Modules.Catalog.Presentation/Templates/AddSectionVariantEndpoint.cs
 create mode 100644 src/Modules/Catalog/Eternelle.Modules.Catalog.Presentation/Templates/AddSupportedSectionEndpoint.cs
 create mode 100644 src/Modules/Catalog/Eternelle.Modules.Catalog.Presentation/Templates/AddTemplateThemeEndpoint.cs
 create mode 100644 src/Modules/Catalog/Eternelle.Modules.Catalog.Presentation/Templates/CreateTemplateEndpoint.cs
 create mode 100644 src/Modules/Catalog/Eternelle.Modules.Catalog.Presentation/Templates/GetSectionVariantsEndpoint.cs
 create mode 100644 src/Modules/Catalog/Eternelle.Modules.Catalog.Presentation/Templates/GetTemplateByIdEndpoint.cs
 create mode 100644 src/Modules/Catalog/Eternelle.Modules.Catalog.Presentation/Templates/GetTemplatesEndpoint.cs
 create mode 100644 src/Modules/Catalog/Eternelle.Modules.Catalog.Presentation/Templates/UpdateTemplateEndpoint.cs

diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Presentation/Tags.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Presentation/Tags.cs
new file mode 100644
index 0000000..143da75
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Presentation/Tags.cs
@@ -0,0 +1,6 @@
+namespace Eternelle.Modules.Catalog.Presentation;
+
+internal static class Tags
+{
+    internal const string Catalog = "Catalog";
+}
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Presentation/Templates/AddSectionVariantEndpoint.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Presentation/Templates/AddSectionVariantEndpoint.cs
new file mode 100644
index 0000000..a0cc128
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Presentation/Templates/AddSectionVariantEndpoint.cs
@@ -0,0 +1,36 @@
+using Eternelle.Common.Domain;
+using Eternelle.Common.Presentation.Endpoints;
+using Eternelle.Common.Presentation.Results;
+using Eternelle.Modules.Catalog.Application.Templates.AddSectionVariant;
+using Eternelle.Modules.Catalog.Domain.Templates;
+using MediatR;
+using Microsoft.AspNetCore.Builder;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Routing;
+
+namespace Eternelle.Modules.Catalog.Presentation.Templates;
+
+internal sealed class AddSectionVariantEndpoint : IEndpoint
+{
+    internal sealed record Request(string Variant, bool IsDefault, PriceClass PriceClass, int? UploadLimit);
+
+    public void MapEndpoint(IEndpointRouteBuilder app)
+    {
+        app.MapPost("catalog/templates/{templateId:guid}/sections/{sectionId}/variants", async (
+            Guid templateId,
+            SectionId sectionId,
+            Request request,
+            ISender sender,
+            CancellationToken cancellationToken) =>
+        {
+            var command = new AddSectionVariantCommand(
+                templateId, sectionId, request.Variant, request.IsDefault, request.PriceClass, request.UploadLimit);
+
+            Result result = await sender.Send(command, cancellationToken);
+
+            return result.Match(Results.NoContent, ApiResults.Problem);
+        })
+        .WithTags(Tags.Catalog)
+        .RequireAuthorization("catalog:manage");
+    }
+}
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Presentation/Templates/AddSupportedSectionEndpoint.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Presentation/Templates/AddSupportedSectionEndpoint.cs
new file mode 100644
index 0000000..80a3a03
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Presentation/Templates/AddSupportedSectionEndpoint.cs
@@ -0,0 +1,34 @@
+using Eternelle.Common.Domain;
+using Eternelle.Common.Presentation.Endpoints;
+using Eternelle.Common.Presentation.Results;
+using Eternelle.Modules.Catalog.Application.Templates.AddSupportedSection;
+using Eternelle.Modules.Catalog.Domain.Templates;
+using MediatR;
+using Microsoft.AspNetCore.Builder;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Routing;
+
+namespace Eternelle.Modules.Catalog.Presentation.Templates;
+
+internal sealed class AddSupportedSectionEndpoint : IEndpoint
+{
+    internal sealed record Request(SectionId SectionId, int DisplayOrder);
+
+    public void MapEndpoint(IEndpointRouteBuilder app)
+    {
+        app.MapPost("catalog/templates/{templateId:guid}/sections", async (
+            Guid templateId,
+            Request request,
+            ISender sender,
+            CancellationToken cancellationToken) =>
+        {
+            var command = new AddSupportedSectionCommand(templateId, request.SectionId, request.DisplayOrder);
+
+            Result result = await sender.Send(command, cancellationToken);
+
+            return result.Match(Results.NoContent, ApiResults.Problem);
+        })
+        .WithTags(Tags.Catalog)
+        .RequireAuthorization("catalog:manage");
+    }
+}
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Presentation/Templates/AddTemplateThemeEndpoint.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Presentation/Templates/AddTemplateThemeEndpoint.cs
new file mode 100644
index 0000000..8ec0032
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Presentation/Templates/AddTemplateThemeEndpoint.cs
@@ -0,0 +1,41 @@
+using Eternelle.Common.Domain;
+using Eternelle.Common.Presentation.Endpoints;
+using Eternelle.Common.Presentation.Results;
+using Eternelle.Modules.Catalog.Application.Templates.AddTemplateTheme;
+using MediatR;
+using Microsoft.AspNetCore.Builder;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Routing;
+
+namespace Eternelle.Modules.Catalog.Presentation.Templates;
+
+internal sealed class AddTemplateThemeEndpoint : IEndpoint
+{
+    internal sealed record Request(
+        int ThemeIndex,
+        string Name,
+        IReadOnlyDictionary<string, string> Colors,
+        IReadOnlyDictionary<string, string> Typography,
+        IReadOnlyDictionary<string, string>? Textures,
+        bool IsDark);
+
+    public void MapEndpoint(IEndpointRouteBuilder app)
+    {
+        app.MapPost("catalog/templates/{templateId:guid}/themes", async (
+            Guid templateId,
+            Request request,
+            ISender sender,
+            CancellationToken cancellationToken) =>
+        {
+            var command = new AddTemplateThemeCommand(
+                templateId, request.ThemeIndex, request.Name,
+                request.Colors, request.Typography, request.Textures, request.IsDark);
+
+            Result result = await sender.Send(command, cancellationToken);
+
+            return result.Match(Results.NoContent, ApiResults.Problem);
+        })
+        .WithTags(Tags.Catalog)
+        .RequireAuthorization("catalog:manage");
+    }
+}
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Presentation/Templates/CreateTemplateEndpoint.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Presentation/Templates/CreateTemplateEndpoint.cs
new file mode 100644
index 0000000..ad86c18
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Presentation/Templates/CreateTemplateEndpoint.cs
@@ -0,0 +1,41 @@
+using Eternelle.Common.Domain;
+using Eternelle.Common.Presentation.Endpoints;
+using Eternelle.Common.Presentation.Results;
+using Eternelle.Modules.Catalog.Application.Templates.CreateTemplate;
+using Eternelle.Modules.Catalog.Domain.Templates;
+using MediatR;
+using Microsoft.AspNetCore.Builder;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Routing;
+
+namespace Eternelle.Modules.Catalog.Presentation.Templates;
+
+internal sealed class CreateTemplateEndpoint : IEndpoint
+{
+    internal sealed record Request(
+        string Name,
+        string? Description,
+        TemplateTier Tier,
+        string? PreviewImageUrl,
+        IReadOnlyList<string>? Features);
+
+    public void MapEndpoint(IEndpointRouteBuilder app)
+    {
+        app.MapPost("catalog/templates", async (
+            Request request,
+            ISender sender,
+            CancellationToken cancellationToken) =>
+        {
+            var command = new CreateTemplateCommand(
+                request.Name, request.Description, request.Tier, request.PreviewImageUrl, request.Features);
+
+            Result<Guid> result = await sender.Send(command, cancellationToken);
+
+            return result.Match(
+                id => Results.Created($"/catalog/templates/{id}", new { id }),
+                ApiResults.Problem);
+        })
+        .WithTags(Tags.Catalog)
+        .RequireAuthorization("catalog:manage");
+    }
+}
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Presentation/Templates/GetSectionVariantsEndpoint.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Presentation/Templates/GetSectionVariantsEndpoint.cs
new file mode 100644
index 0000000..6c04779
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Presentation/Templates/GetSectionVariantsEndpoint.cs
@@ -0,0 +1,32 @@
+using Eternelle.Common.Domain;
+using Eternelle.Common.Presentation.Endpoints;
+using Eternelle.Common.Presentation.Results;
+using Eternelle.Modules.Catalog.Application.Templates.GetSectionVariants;
+using Eternelle.Modules.Catalog.Application.Templates.GetTemplateById;
+using Eternelle.Modules.Catalog.Domain.Templates;
+using MediatR;
+using Microsoft.AspNetCore.Builder;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Routing;
+
+namespace Eternelle.Modules.Catalog.Presentation.Templates;
+
+internal sealed class GetSectionVariantsEndpoint : IEndpoint
+{
+    public void MapEndpoint(IEndpointRouteBuilder app)
+    {
+        app.MapGet("catalog/templates/{templateId:guid}/sections/{sectionId}/variants", async (
+            Guid templateId,
+            SectionId sectionId,
+            ISender sender,
+            CancellationToken cancellationToken) =>
+        {
+            Result<IReadOnlyList<SectionVariantResponse>> result =
+                await sender.Send(new GetSectionVariantsQuery(templateId, sectionId), cancellationToken);
+
+            return result.Match(Results.Ok, ApiResults.Problem);
+        })
+        .WithTags(Tags.Catalog)
+        .AllowAnonymous();
+    }
+}
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Presentation/Templates/GetTemplateByIdEndpoint.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Presentation/Templates/GetTemplateByIdEndpoint.cs
new file mode 100644
index 0000000..4c7c68f
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Presentation/Templates/GetTemplateByIdEndpoint.cs
@@ -0,0 +1,29 @@
+using Eternelle.Common.Domain;
+using Eternelle.Common.Presentation.Endpoints;
+using Eternelle.Common.Presentation.Results;
+using Eternelle.Modules.Catalog.Application.Templates.GetTemplateById;
+using MediatR;
+using Microsoft.AspNetCore.Builder;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Routing;
+
+namespace Eternelle.Modules.Catalog.Presentation.Templates;
+
+internal sealed class GetTemplateByIdEndpoint : IEndpoint
+{
+    public void MapEndpoint(IEndpointRouteBuilder app)
+    {
+        app.MapGet("catalog/templates/{templateId:guid}", async (
+            Guid templateId,
+            ISender sender,
+            CancellationToken cancellationToken) =>
+        {
+            Result<TemplateDetailResponse> result =
+                await sender.Send(new GetTemplateByIdQuery(templateId), cancellationToken);
+
+            return result.Match(Results.Ok, ApiResults.Problem);
+        })
+        .WithTags(Tags.Catalog)
+        .AllowAnonymous();
+    }
+}
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Presentation/Templates/GetTemplatesEndpoint.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Presentation/Templates/GetTemplatesEndpoint.cs
new file mode 100644
index 0000000..7ca21de
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Presentation/Templates/GetTemplatesEndpoint.cs
@@ -0,0 +1,30 @@
+using Eternelle.Common.Domain;
+using Eternelle.Common.Presentation.Endpoints;
+using Eternelle.Common.Presentation.Results;
+using Eternelle.Modules.Catalog.Application.Templates.GetTemplates;
+using Eternelle.Modules.Catalog.Domain.Templates;
+using MediatR;
+using Microsoft.AspNetCore.Builder;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Routing;
+
+namespace Eternelle.Modules.Catalog.Presentation.Templates;
+
+internal sealed class GetTemplatesEndpoint : IEndpoint
+{
+    public void MapEndpoint(IEndpointRouteBuilder app)
+    {
+        app.MapGet("catalog/templates", async (
+            TemplateTier? tier,
+            ISender sender,
+            CancellationToken cancellationToken) =>
+        {
+            Result<IReadOnlyList<TemplateSummaryResponse>> result =
+                await sender.Send(new GetTemplatesQuery(tier), cancellationToken);
+
+            return result.Match(Results.Ok, ApiResults.Problem);
+        })
+        .WithTags(Tags.Catalog)
+        .AllowAnonymous();
+    }
+}
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Presentation/Templates/UpdateTemplateEndpoint.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Presentation/Templates/UpdateTemplateEndpoint.cs
new file mode 100644
index 0000000..ca644c3
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Presentation/Templates/UpdateTemplateEndpoint.cs
@@ -0,0 +1,38 @@
+using Eternelle.Common.Domain;
+using Eternelle.Common.Presentation.Endpoints;
+using Eternelle.Common.Presentation.Results;
+using Eternelle.Modules.Catalog.Application.Templates.UpdateTemplate;
+using MediatR;
+using Microsoft.AspNetCore.Builder;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Routing;
+
+namespace Eternelle.Modules.Catalog.Presentation.Templates;
+
+internal sealed class UpdateTemplateEndpoint : IEndpoint
+{
+    internal sealed record Request(
+        string Name,
+        string? Description,
+        string? PreviewImageUrl,
+        IReadOnlyList<string>? Features);
+
+    public void MapEndpoint(IEndpointRouteBuilder app)
+    {
+        app.MapPut("catalog/templates/{templateId:guid}", async (
+            Guid templateId,
+            Request request,
+            ISender sender,
+            CancellationToken cancellationToken) =>
+        {
+            var command = new UpdateTemplateCommand(
+                templateId, request.Name, request.Description, request.PreviewImageUrl, request.Features);
+
+            Result result = await sender.Send(command, cancellationToken);
+
+            return result.Match(Results.NoContent, ApiResults.Problem);
+        })
+        .WithTags(Tags.Catalog)
+        .RequireAuthorization("catalog:manage");
+    }
+}

From 6be8d995b40cf0a8d12dff31b65deac819dfb7e4 Mon Sep 17 00:00:00 2001
From: Carl Marion <carlmarion.develops@gmail.com>
Date: Wed, 27 May 2026 17:57:21 +0800
Subject: [PATCH 26/31] Eternelle-180 Wire Catalog module into the API host and
 add initial migration

Registers CatalogModule in Program.cs (assembly, config, DI), adds catalog config
files, and generates the InitialCatalog EF migration with Kapilya seed data.
---
 src/API/Eternelle.Api/Eternelle.Api.csproj    |   1 +
 src/API/Eternelle.Api/Program.cs              |   8 +-
 .../modules.catalog.Development.json          |   8 +
 src/API/Eternelle.Api/modules.catalog.json    |   8 +
 .../20260527094230_InitialCatalog.Designer.cs | 302 ++++++++++++++++++
 .../20260527094230_InitialCatalog.cs          | 248 ++++++++++++++
 .../CatalogDbContextModelSnapshot.cs          | 299 +++++++++++++++++
 7 files changed, 872 insertions(+), 2 deletions(-)
 create mode 100644 src/API/Eternelle.Api/modules.catalog.Development.json
 create mode 100644 src/API/Eternelle.Api/modules.catalog.json
 create mode 100644 src/Modules/Catalog/Eternelle.Modules.Catalog.Infrastructure/Database/Migrations/20260527094230_InitialCatalog.Designer.cs
 create mode 100644 src/Modules/Catalog/Eternelle.Modules.Catalog.Infrastructure/Database/Migrations/20260527094230_InitialCatalog.cs
 create mode 100644 src/Modules/Catalog/Eternelle.Modules.Catalog.Infrastructure/Database/Migrations/CatalogDbContextModelSnapshot.cs

diff --git a/src/API/Eternelle.Api/Eternelle.Api.csproj b/src/API/Eternelle.Api/Eternelle.Api.csproj
index cc488d7..991e197 100644
--- a/src/API/Eternelle.Api/Eternelle.Api.csproj
+++ b/src/API/Eternelle.Api/Eternelle.Api.csproj
@@ -21,6 +21,7 @@
   </ItemGroup>
 
   <ItemGroup>
+    <ProjectReference Include="..\..\Modules\Catalog\Eternelle.Modules.Catalog.Infrastructure\Eternelle.Modules.Catalog.Infrastructure.csproj" />
     <ProjectReference Include="..\..\Modules\Users\Eternelle.Modules.Users.Infrastructure\Eternelle.Modules.Users.Infrastructure.csproj" />
     <ProjectReference Include="..\..\Modules\Weddings\Eternelle.Modules.Weddings.Infrastructure\Eternelle.Modules.Weddings.Infrastructure.csproj" />
   </ItemGroup>
diff --git a/src/API/Eternelle.Api/Program.cs b/src/API/Eternelle.Api/Program.cs
index b77968e..df3a262 100644
--- a/src/API/Eternelle.Api/Program.cs
+++ b/src/API/Eternelle.Api/Program.cs
@@ -6,6 +6,7 @@
 using Eternelle.Common.Infrastructure;
 using Eternelle.Common.Infrastructure.Configuration;
 using Eternelle.Common.Presentation.Endpoints;
+using Eternelle.Modules.Catalog.Infrastructure;
 using Eternelle.Modules.Users.Infrastructure;
 using Eternelle.Modules.Weddings.Infrastructure;
 using Eternelle.Modules.Weddings.Presentation;
@@ -25,7 +26,8 @@
 
 builder.Services.AddApplication([
     Eternelle.Modules.Weddings.Application.AssemblyReference.Assembly,
-    Eternelle.Modules.Users.Application.AssemblyReference.Assembly
+    Eternelle.Modules.Users.Application.AssemblyReference.Assembly,
+    Eternelle.Modules.Catalog.Application.AssemblyReference.Assembly
 ]);
 
 string databaseConnectionString = builder.Configuration.GetConnectionStringOrThrow("Database");
@@ -37,7 +39,7 @@
     databaseConnectionString: databaseConnectionString,
     redisConnectionString: redisConnectionString);
 
-builder.Configuration.AddModuleConfiguration(["weddings", "users"]);
+builder.Configuration.AddModuleConfiguration(["weddings", "users", "catalog"]);
 
 Uri keyCloakHealthUrl = builder.Configuration.GetKeyCloakHealthUrl();
 
@@ -50,6 +52,8 @@
 
 builder.Services.AddUsersModule(builder.Configuration);
 
+builder.Services.AddCatalogModule(builder.Configuration);
+
 builder.Services.AddRateLimiter(options =>
 {
     // IP-based fixed-window limiter for the public guest photo upload endpoint.
diff --git a/src/API/Eternelle.Api/modules.catalog.Development.json b/src/API/Eternelle.Api/modules.catalog.Development.json
new file mode 100644
index 0000000..61dfc8c
--- /dev/null
+++ b/src/API/Eternelle.Api/modules.catalog.Development.json
@@ -0,0 +1,8 @@
+{
+  "Catalog": {
+    "Outbox": {
+      "IntervalInSeconds": 10,
+      "BatchSize": 10
+    }
+  }
+}
diff --git a/src/API/Eternelle.Api/modules.catalog.json b/src/API/Eternelle.Api/modules.catalog.json
new file mode 100644
index 0000000..61dfc8c
--- /dev/null
+++ b/src/API/Eternelle.Api/modules.catalog.json
@@ -0,0 +1,8 @@
+{
+  "Catalog": {
+    "Outbox": {
+      "IntervalInSeconds": 10,
+      "BatchSize": 10
+    }
+  }
+}
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Infrastructure/Database/Migrations/20260527094230_InitialCatalog.Designer.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Infrastructure/Database/Migrations/20260527094230_InitialCatalog.Designer.cs
new file mode 100644
index 0000000..cb09aa6
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Infrastructure/Database/Migrations/20260527094230_InitialCatalog.Designer.cs
@@ -0,0 +1,302 @@
+// <auto-generated />
+using System;
+using Eternelle.Modules.Catalog.Infrastructure.Database;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+
+#nullable disable
+
+namespace Eternelle.Modules.Catalog.Infrastructure.Database.Migrations
+{
+    [DbContext(typeof(CatalogDbContext))]
+    [Migration("20260527094230_InitialCatalog")]
+    partial class InitialCatalog
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasDefaultSchema("catalog")
+                .HasAnnotation("ProductVersion", "10.0.4")
+                .HasAnnotation("Relational:MaxIdentifierLength", 63);
+
+            NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
+
+            modelBuilder.Entity("Eternelle.Common.Infrastructure.Outbox.OutboxMessage", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid")
+                        .HasColumnName("id");
+
+                    b.Property<string>("Content")
+                        .IsRequired()
+                        .HasMaxLength(2000)
+                        .HasColumnType("jsonb")
+                        .HasColumnName("content");
+
+                    b.Property<string>("Error")
+                        .HasColumnType("text")
+                        .HasColumnName("error");
+
+                    b.Property<DateTime>("OccurredOnUtc")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("occurred_on_utc");
+
+                    b.Property<DateTime?>("ProcessedOnUtc")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("processed_on_utc");
+
+                    b.Property<string>("Type")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("type");
+
+                    b.HasKey("Id")
+                        .HasName("pk_outbox_messages");
+
+                    b.ToTable("outbox_messages", "catalog");
+                });
+
+            modelBuilder.Entity("Eternelle.Common.Infrastructure.Outbox.OutboxMessageConsumer", b =>
+                {
+                    b.Property<Guid>("OutboxMessageId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("outbox_message_id");
+
+                    b.Property<string>("Name")
+                        .HasMaxLength(500)
+                        .HasColumnType("character varying(500)")
+                        .HasColumnName("name");
+
+                    b.HasKey("OutboxMessageId", "Name")
+                        .HasName("pk_outbox_message_consumers");
+
+                    b.ToTable("outbox_message_consumers", "catalog");
+                });
+
+            modelBuilder.Entity("Eternelle.Modules.Catalog.Domain.Templates.Template", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid")
+                        .HasColumnName("id");
+
+                    b.Property<DateTime>("CreatedAtUtc")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("created_at_utc");
+
+                    b.Property<string>("Description")
+                        .HasMaxLength(1000)
+                        .HasColumnType("character varying(1000)")
+                        .HasColumnName("description");
+
+                    b.Property<string>("Features")
+                        .IsRequired()
+                        .HasColumnType("jsonb")
+                        .HasColumnName("features");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(150)
+                        .HasColumnType("character varying(150)")
+                        .HasColumnName("name");
+
+                    b.Property<string>("PreviewImageUrl")
+                        .HasMaxLength(2048)
+                        .HasColumnType("character varying(2048)")
+                        .HasColumnName("preview_image_url");
+
+                    b.Property<string>("Tier")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("tier");
+
+                    b.Property<DateTime>("UpdatedAtUtc")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("updated_at_utc");
+
+                    b.HasKey("Id")
+                        .HasName("pk_templates");
+
+                    b.HasIndex("Name")
+                        .IsUnique()
+                        .HasDatabaseName("ix_templates_name");
+
+                    b.ToTable("templates", "catalog");
+                });
+
+            modelBuilder.Entity("Eternelle.Modules.Catalog.Domain.Templates.TemplateSectionVariant", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid")
+                        .HasColumnName("id");
+
+                    b.Property<bool>("IsDefault")
+                        .HasColumnType("boolean")
+                        .HasColumnName("is_default");
+
+                    b.Property<string>("PriceClass")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)")
+                        .HasColumnName("price_class");
+
+                    b.Property<string>("SectionId")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)")
+                        .HasColumnName("section_id");
+
+                    b.Property<Guid>("TemplateId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("template_id");
+
+                    b.Property<int?>("UploadLimit")
+                        .HasColumnType("integer")
+                        .HasColumnName("upload_limit");
+
+                    b.Property<string>("Variant")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)")
+                        .HasColumnName("variant");
+
+                    b.HasKey("Id")
+                        .HasName("pk_template_section_variants");
+
+                    b.HasIndex("TemplateId", "SectionId")
+                        .IsUnique()
+                        .HasDatabaseName("ux_template_section_variants_one_default")
+                        .HasFilter("is_default = true");
+
+                    b.HasIndex("TemplateId", "SectionId", "Variant")
+                        .IsUnique()
+                        .HasDatabaseName("ix_template_section_variants_template_id_section_id_variant");
+
+                    b.ToTable("template_section_variants", "catalog");
+                });
+
+            modelBuilder.Entity("Eternelle.Modules.Catalog.Domain.Templates.TemplateSupportedSection", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid")
+                        .HasColumnName("id");
+
+                    b.Property<int>("DisplayOrder")
+                        .HasColumnType("integer")
+                        .HasColumnName("display_order");
+
+                    b.Property<string>("SectionId")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)")
+                        .HasColumnName("section_id");
+
+                    b.Property<Guid>("TemplateId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("template_id");
+
+                    b.HasKey("Id")
+                        .HasName("pk_template_supported_sections");
+
+                    b.HasIndex("TemplateId", "SectionId")
+                        .IsUnique()
+                        .HasDatabaseName("ix_template_supported_sections_template_id_section_id");
+
+                    b.ToTable("template_supported_sections", "catalog");
+                });
+
+            modelBuilder.Entity("Eternelle.Modules.Catalog.Domain.Templates.TemplateTheme", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid")
+                        .HasColumnName("id");
+
+                    b.Property<string>("Colors")
+                        .IsRequired()
+                        .HasColumnType("jsonb")
+                        .HasColumnName("colors");
+
+                    b.Property<bool>("IsDark")
+                        .HasColumnType("boolean")
+                        .HasColumnName("is_dark");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)")
+                        .HasColumnName("name");
+
+                    b.Property<Guid>("TemplateId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("template_id");
+
+                    b.Property<string>("Textures")
+                        .HasColumnType("jsonb")
+                        .HasColumnName("textures");
+
+                    b.Property<int>("ThemeIndex")
+                        .HasColumnType("integer")
+                        .HasColumnName("theme_index");
+
+                    b.Property<string>("Typography")
+                        .IsRequired()
+                        .HasColumnType("jsonb")
+                        .HasColumnName("typography");
+
+                    b.HasKey("Id")
+                        .HasName("pk_template_themes");
+
+                    b.HasIndex("TemplateId", "ThemeIndex")
+                        .IsUnique()
+                        .HasDatabaseName("ix_template_themes_template_id_theme_index");
+
+                    b.ToTable("template_themes", "catalog");
+                });
+
+            modelBuilder.Entity("Eternelle.Modules.Catalog.Domain.Templates.TemplateSectionVariant", b =>
+                {
+                    b.HasOne("Eternelle.Modules.Catalog.Domain.Templates.Template", null)
+                        .WithMany("SectionVariants")
+                        .HasForeignKey("TemplateId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("fk_template_section_variants_templates_template_id");
+                });
+
+            modelBuilder.Entity("Eternelle.Modules.Catalog.Domain.Templates.TemplateSupportedSection", b =>
+                {
+                    b.HasOne("Eternelle.Modules.Catalog.Domain.Templates.Template", null)
+                        .WithMany("SupportedSections")
+                        .HasForeignKey("TemplateId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("fk_template_supported_sections_templates_template_id");
+                });
+
+            modelBuilder.Entity("Eternelle.Modules.Catalog.Domain.Templates.TemplateTheme", b =>
+                {
+                    b.HasOne("Eternelle.Modules.Catalog.Domain.Templates.Template", null)
+                        .WithMany("Themes")
+                        .HasForeignKey("TemplateId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("fk_template_themes_templates_template_id");
+                });
+
+            modelBuilder.Entity("Eternelle.Modules.Catalog.Domain.Templates.Template", b =>
+                {
+                    b.Navigation("SectionVariants");
+
+                    b.Navigation("SupportedSections");
+
+                    b.Navigation("Themes");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Infrastructure/Database/Migrations/20260527094230_InitialCatalog.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Infrastructure/Database/Migrations/20260527094230_InitialCatalog.cs
new file mode 100644
index 0000000..ed89e38
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Infrastructure/Database/Migrations/20260527094230_InitialCatalog.cs
@@ -0,0 +1,248 @@
+using System;
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace Eternelle.Modules.Catalog.Infrastructure.Database.Migrations
+{
+    /// <inheritdoc />
+    public partial class InitialCatalog : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.EnsureSchema(
+                name: "catalog");
+
+            migrationBuilder.CreateTable(
+                name: "outbox_message_consumers",
+                schema: "catalog",
+                columns: table => new
+                {
+                    outbox_message_id = table.Column<Guid>(type: "uuid", nullable: false),
+                    name = table.Column<string>(type: "character varying(500)", maxLength: 500, nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("pk_outbox_message_consumers", x => new { x.outbox_message_id, x.name });
+                });
+
+            migrationBuilder.CreateTable(
+                name: "outbox_messages",
+                schema: "catalog",
+                columns: table => new
+                {
+                    id = table.Column<Guid>(type: "uuid", nullable: false),
+                    type = table.Column<string>(type: "text", nullable: false),
+                    content = table.Column<string>(type: "jsonb", maxLength: 2000, nullable: false),
+                    occurred_on_utc = table.Column<DateTime>(type: "timestamp with time zone", nullable: false),
+                    processed_on_utc = table.Column<DateTime>(type: "timestamp with time zone", nullable: true),
+                    error = table.Column<string>(type: "text", nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("pk_outbox_messages", x => x.id);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "templates",
+                schema: "catalog",
+                columns: table => new
+                {
+                    id = table.Column<Guid>(type: "uuid", nullable: false),
+                    name = table.Column<string>(type: "character varying(150)", maxLength: 150, nullable: false),
+                    description = table.Column<string>(type: "character varying(1000)", maxLength: 1000, nullable: true),
+                    tier = table.Column<string>(type: "text", nullable: false),
+                    preview_image_url = table.Column<string>(type: "character varying(2048)", maxLength: 2048, nullable: true),
+                    features = table.Column<string>(type: "jsonb", nullable: false),
+                    created_at_utc = table.Column<DateTime>(type: "timestamp with time zone", nullable: false),
+                    updated_at_utc = table.Column<DateTime>(type: "timestamp with time zone", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("pk_templates", x => x.id);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "template_section_variants",
+                schema: "catalog",
+                columns: table => new
+                {
+                    id = table.Column<Guid>(type: "uuid", nullable: false),
+                    template_id = table.Column<Guid>(type: "uuid", nullable: false),
+                    section_id = table.Column<string>(type: "character varying(50)", maxLength: 50, nullable: false),
+                    variant = table.Column<string>(type: "character varying(100)", maxLength: 100, nullable: false),
+                    is_default = table.Column<bool>(type: "boolean", nullable: false),
+                    price_class = table.Column<string>(type: "character varying(50)", maxLength: 50, nullable: false),
+                    upload_limit = table.Column<int>(type: "integer", nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("pk_template_section_variants", x => x.id);
+                    table.ForeignKey(
+                        name: "fk_template_section_variants_templates_template_id",
+                        column: x => x.template_id,
+                        principalSchema: "catalog",
+                        principalTable: "templates",
+                        principalColumn: "id",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "template_supported_sections",
+                schema: "catalog",
+                columns: table => new
+                {
+                    id = table.Column<Guid>(type: "uuid", nullable: false),
+                    template_id = table.Column<Guid>(type: "uuid", nullable: false),
+                    section_id = table.Column<string>(type: "character varying(50)", maxLength: 50, nullable: false),
+                    display_order = table.Column<int>(type: "integer", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("pk_template_supported_sections", x => x.id);
+                    table.ForeignKey(
+                        name: "fk_template_supported_sections_templates_template_id",
+                        column: x => x.template_id,
+                        principalSchema: "catalog",
+                        principalTable: "templates",
+                        principalColumn: "id",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "template_themes",
+                schema: "catalog",
+                columns: table => new
+                {
+                    id = table.Column<Guid>(type: "uuid", nullable: false),
+                    template_id = table.Column<Guid>(type: "uuid", nullable: false),
+                    theme_index = table.Column<int>(type: "integer", nullable: false),
+                    name = table.Column<string>(type: "character varying(100)", maxLength: 100, nullable: false),
+                    colors = table.Column<string>(type: "jsonb", nullable: false),
+                    typography = table.Column<string>(type: "jsonb", nullable: false),
+                    textures = table.Column<string>(type: "jsonb", nullable: true),
+                    is_dark = table.Column<bool>(type: "boolean", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("pk_template_themes", x => x.id);
+                    table.ForeignKey(
+                        name: "fk_template_themes_templates_template_id",
+                        column: x => x.template_id,
+                        principalSchema: "catalog",
+                        principalTable: "templates",
+                        principalColumn: "id",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateIndex(
+                name: "ix_template_section_variants_template_id_section_id_variant",
+                schema: "catalog",
+                table: "template_section_variants",
+                columns: new[] { "template_id", "section_id", "variant" },
+                unique: true);
+
+            migrationBuilder.CreateIndex(
+                name: "ux_template_section_variants_one_default",
+                schema: "catalog",
+                table: "template_section_variants",
+                columns: new[] { "template_id", "section_id" },
+                unique: true,
+                filter: "is_default = true");
+
+            migrationBuilder.CreateIndex(
+                name: "ix_template_supported_sections_template_id_section_id",
+                schema: "catalog",
+                table: "template_supported_sections",
+                columns: new[] { "template_id", "section_id" },
+                unique: true);
+
+            migrationBuilder.CreateIndex(
+                name: "ix_template_themes_template_id_theme_index",
+                schema: "catalog",
+                table: "template_themes",
+                columns: new[] { "template_id", "theme_index" },
+                unique: true);
+
+            migrationBuilder.CreateIndex(
+                name: "ix_templates_name",
+                schema: "catalog",
+                table: "templates",
+                column: "name",
+                unique: true);
+
+            migrationBuilder.Sql(
+                """
+                INSERT INTO catalog.templates (id, name, description, tier, preview_image_url, features, created_at_utc, updated_at_utc)
+                VALUES (
+                    '0190a000-0000-7000-8000-000000000001',
+                    'Kapilya',
+                    'A classic Filipino chapel-inspired wedding template.',
+                    'FirstClass',
+                    NULL,
+                    '[]'::jsonb,
+                    now() AT TIME ZONE 'utc',
+                    now() AT TIME ZONE 'utc');
+
+                INSERT INTO catalog.template_themes (id, template_id, theme_index, name, colors, typography, textures, is_dark)
+                VALUES
+                    ('0190a000-0000-7000-8000-000000000010', '0190a000-0000-7000-8000-000000000001', 0, 'Ivory',
+                     '{"primary":"#1a1a1a","accent":"#c8a96a","background":"#faf7f2"}'::jsonb,
+                     '{"heading":"Cormorant","body":"Inter"}'::jsonb, NULL, false),
+                    ('0190a000-0000-7000-8000-000000000011', '0190a000-0000-7000-8000-000000000001', 1, 'Midnight',
+                     '{"primary":"#f5f5f5","accent":"#c8a96a","background":"#10100f"}'::jsonb,
+                     '{"heading":"Cormorant","body":"Inter"}'::jsonb, NULL, true);
+
+                INSERT INTO catalog.template_supported_sections (id, template_id, section_id, display_order)
+                VALUES
+                    ('0190a000-0000-7000-8000-000000000020', '0190a000-0000-7000-8000-000000000001', 'Hero', 0),
+                    ('0190a000-0000-7000-8000-000000000021', '0190a000-0000-7000-8000-000000000001', 'Story', 1),
+                    ('0190a000-0000-7000-8000-000000000022', '0190a000-0000-7000-8000-000000000001', 'Entourage', 2),
+                    ('0190a000-0000-7000-8000-000000000023', '0190a000-0000-7000-8000-000000000001', 'Venue', 3),
+                    ('0190a000-0000-7000-8000-000000000024', '0190a000-0000-7000-8000-000000000001', 'Rsvp', 4),
+                    ('0190a000-0000-7000-8000-000000000025', '0190a000-0000-7000-8000-000000000001', 'GuestUploads', 5);
+
+                INSERT INTO catalog.template_section_variants (id, template_id, section_id, variant, is_default, price_class, upload_limit)
+                VALUES
+                    ('0190a000-0000-7000-8000-000000000030', '0190a000-0000-7000-8000-000000000001', 'Hero', 'classic', true, 'Free', NULL),
+                    ('0190a000-0000-7000-8000-000000000031', '0190a000-0000-7000-8000-000000000001', 'Hero', 'editorial', false, 'Plus', NULL),
+                    ('0190a000-0000-7000-8000-000000000032', '0190a000-0000-7000-8000-000000000001', 'Story', 'classic', true, 'Free', NULL),
+                    ('0190a000-0000-7000-8000-000000000033', '0190a000-0000-7000-8000-000000000001', 'Entourage', 'grid', true, 'Free', NULL),
+                    ('0190a000-0000-7000-8000-000000000034', '0190a000-0000-7000-8000-000000000001', 'Venue', 'map', true, 'Free', NULL),
+                    ('0190a000-0000-7000-8000-000000000035', '0190a000-0000-7000-8000-000000000001', 'Rsvp', 'simple', true, 'Free', NULL),
+                    ('0190a000-0000-7000-8000-000000000036', '0190a000-0000-7000-8000-000000000001', 'GuestUploads', 'free', true, 'Free', 50),
+                    ('0190a000-0000-7000-8000-000000000037', '0190a000-0000-7000-8000-000000000001', 'GuestUploads', 'pro', false, 'Pro', 250),
+                    ('0190a000-0000-7000-8000-000000000038', '0190a000-0000-7000-8000-000000000001', 'GuestUploads', 'plus', false, 'Plus', NULL);
+                """);
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropTable(
+                name: "outbox_message_consumers",
+                schema: "catalog");
+
+            migrationBuilder.DropTable(
+                name: "outbox_messages",
+                schema: "catalog");
+
+            migrationBuilder.DropTable(
+                name: "template_section_variants",
+                schema: "catalog");
+
+            migrationBuilder.DropTable(
+                name: "template_supported_sections",
+                schema: "catalog");
+
+            migrationBuilder.DropTable(
+                name: "template_themes",
+                schema: "catalog");
+
+            migrationBuilder.DropTable(
+                name: "templates",
+                schema: "catalog");
+        }
+    }
+}
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Infrastructure/Database/Migrations/CatalogDbContextModelSnapshot.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Infrastructure/Database/Migrations/CatalogDbContextModelSnapshot.cs
new file mode 100644
index 0000000..50e4645
--- /dev/null
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Infrastructure/Database/Migrations/CatalogDbContextModelSnapshot.cs
@@ -0,0 +1,299 @@
+// <auto-generated />
+using System;
+using Eternelle.Modules.Catalog.Infrastructure.Database;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+
+#nullable disable
+
+namespace Eternelle.Modules.Catalog.Infrastructure.Database.Migrations
+{
+    [DbContext(typeof(CatalogDbContext))]
+    partial class CatalogDbContextModelSnapshot : ModelSnapshot
+    {
+        protected override void BuildModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasDefaultSchema("catalog")
+                .HasAnnotation("ProductVersion", "10.0.4")
+                .HasAnnotation("Relational:MaxIdentifierLength", 63);
+
+            NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
+
+            modelBuilder.Entity("Eternelle.Common.Infrastructure.Outbox.OutboxMessage", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid")
+                        .HasColumnName("id");
+
+                    b.Property<string>("Content")
+                        .IsRequired()
+                        .HasMaxLength(2000)
+                        .HasColumnType("jsonb")
+                        .HasColumnName("content");
+
+                    b.Property<string>("Error")
+                        .HasColumnType("text")
+                        .HasColumnName("error");
+
+                    b.Property<DateTime>("OccurredOnUtc")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("occurred_on_utc");
+
+                    b.Property<DateTime?>("ProcessedOnUtc")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("processed_on_utc");
+
+                    b.Property<string>("Type")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("type");
+
+                    b.HasKey("Id")
+                        .HasName("pk_outbox_messages");
+
+                    b.ToTable("outbox_messages", "catalog");
+                });
+
+            modelBuilder.Entity("Eternelle.Common.Infrastructure.Outbox.OutboxMessageConsumer", b =>
+                {
+                    b.Property<Guid>("OutboxMessageId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("outbox_message_id");
+
+                    b.Property<string>("Name")
+                        .HasMaxLength(500)
+                        .HasColumnType("character varying(500)")
+                        .HasColumnName("name");
+
+                    b.HasKey("OutboxMessageId", "Name")
+                        .HasName("pk_outbox_message_consumers");
+
+                    b.ToTable("outbox_message_consumers", "catalog");
+                });
+
+            modelBuilder.Entity("Eternelle.Modules.Catalog.Domain.Templates.Template", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid")
+                        .HasColumnName("id");
+
+                    b.Property<DateTime>("CreatedAtUtc")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("created_at_utc");
+
+                    b.Property<string>("Description")
+                        .HasMaxLength(1000)
+                        .HasColumnType("character varying(1000)")
+                        .HasColumnName("description");
+
+                    b.Property<string>("Features")
+                        .IsRequired()
+                        .HasColumnType("jsonb")
+                        .HasColumnName("features");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(150)
+                        .HasColumnType("character varying(150)")
+                        .HasColumnName("name");
+
+                    b.Property<string>("PreviewImageUrl")
+                        .HasMaxLength(2048)
+                        .HasColumnType("character varying(2048)")
+                        .HasColumnName("preview_image_url");
+
+                    b.Property<string>("Tier")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("tier");
+
+                    b.Property<DateTime>("UpdatedAtUtc")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("updated_at_utc");
+
+                    b.HasKey("Id")
+                        .HasName("pk_templates");
+
+                    b.HasIndex("Name")
+                        .IsUnique()
+                        .HasDatabaseName("ix_templates_name");
+
+                    b.ToTable("templates", "catalog");
+                });
+
+            modelBuilder.Entity("Eternelle.Modules.Catalog.Domain.Templates.TemplateSectionVariant", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid")
+                        .HasColumnName("id");
+
+                    b.Property<bool>("IsDefault")
+                        .HasColumnType("boolean")
+                        .HasColumnName("is_default");
+
+                    b.Property<string>("PriceClass")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)")
+                        .HasColumnName("price_class");
+
+                    b.Property<string>("SectionId")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)")
+                        .HasColumnName("section_id");
+
+                    b.Property<Guid>("TemplateId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("template_id");
+
+                    b.Property<int?>("UploadLimit")
+                        .HasColumnType("integer")
+                        .HasColumnName("upload_limit");
+
+                    b.Property<string>("Variant")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)")
+                        .HasColumnName("variant");
+
+                    b.HasKey("Id")
+                        .HasName("pk_template_section_variants");
+
+                    b.HasIndex("TemplateId", "SectionId")
+                        .IsUnique()
+                        .HasDatabaseName("ux_template_section_variants_one_default")
+                        .HasFilter("is_default = true");
+
+                    b.HasIndex("TemplateId", "SectionId", "Variant")
+                        .IsUnique()
+                        .HasDatabaseName("ix_template_section_variants_template_id_section_id_variant");
+
+                    b.ToTable("template_section_variants", "catalog");
+                });
+
+            modelBuilder.Entity("Eternelle.Modules.Catalog.Domain.Templates.TemplateSupportedSection", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid")
+                        .HasColumnName("id");
+
+                    b.Property<int>("DisplayOrder")
+                        .HasColumnType("integer")
+                        .HasColumnName("display_order");
+
+                    b.Property<string>("SectionId")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)")
+                        .HasColumnName("section_id");
+
+                    b.Property<Guid>("TemplateId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("template_id");
+
+                    b.HasKey("Id")
+                        .HasName("pk_template_supported_sections");
+
+                    b.HasIndex("TemplateId", "SectionId")
+                        .IsUnique()
+                        .HasDatabaseName("ix_template_supported_sections_template_id_section_id");
+
+                    b.ToTable("template_supported_sections", "catalog");
+                });
+
+            modelBuilder.Entity("Eternelle.Modules.Catalog.Domain.Templates.TemplateTheme", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid")
+                        .HasColumnName("id");
+
+                    b.Property<string>("Colors")
+                        .IsRequired()
+                        .HasColumnType("jsonb")
+                        .HasColumnName("colors");
+
+                    b.Property<bool>("IsDark")
+                        .HasColumnType("boolean")
+                        .HasColumnName("is_dark");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)")
+                        .HasColumnName("name");
+
+                    b.Property<Guid>("TemplateId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("template_id");
+
+                    b.Property<string>("Textures")
+                        .HasColumnType("jsonb")
+                        .HasColumnName("textures");
+
+                    b.Property<int>("ThemeIndex")
+                        .HasColumnType("integer")
+                        .HasColumnName("theme_index");
+
+                    b.Property<string>("Typography")
+                        .IsRequired()
+                        .HasColumnType("jsonb")
+                        .HasColumnName("typography");
+
+                    b.HasKey("Id")
+                        .HasName("pk_template_themes");
+
+                    b.HasIndex("TemplateId", "ThemeIndex")
+                        .IsUnique()
+                        .HasDatabaseName("ix_template_themes_template_id_theme_index");
+
+                    b.ToTable("template_themes", "catalog");
+                });
+
+            modelBuilder.Entity("Eternelle.Modules.Catalog.Domain.Templates.TemplateSectionVariant", b =>
+                {
+                    b.HasOne("Eternelle.Modules.Catalog.Domain.Templates.Template", null)
+                        .WithMany("SectionVariants")
+                        .HasForeignKey("TemplateId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("fk_template_section_variants_templates_template_id");
+                });
+
+            modelBuilder.Entity("Eternelle.Modules.Catalog.Domain.Templates.TemplateSupportedSection", b =>
+                {
+                    b.HasOne("Eternelle.Modules.Catalog.Domain.Templates.Template", null)
+                        .WithMany("SupportedSections")
+                        .HasForeignKey("TemplateId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("fk_template_supported_sections_templates_template_id");
+                });
+
+            modelBuilder.Entity("Eternelle.Modules.Catalog.Domain.Templates.TemplateTheme", b =>
+                {
+                    b.HasOne("Eternelle.Modules.Catalog.Domain.Templates.Template", null)
+                        .WithMany("Themes")
+                        .HasForeignKey("TemplateId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("fk_template_themes_templates_template_id");
+                });
+
+            modelBuilder.Entity("Eternelle.Modules.Catalog.Domain.Templates.Template", b =>
+                {
+                    b.Navigation("SectionVariants");
+
+                    b.Navigation("SupportedSections");
+
+                    b.Navigation("Themes");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

From 23873b55773b0dcd60e66d3713fe5ae423b35eb9 Mon Sep 17 00:00:00 2001
From: Carl Marion <carlmarion.develops@gmail.com>
Date: Wed, 27 May 2026 18:18:46 +0800
Subject: [PATCH 27/31] Eternelle-180 Seed catalog:manage permission for Admin
 role

Adds a Users migration that inserts the catalog:manage permission and
assigns it to the Admin role, enabling authorized catalog management
operations.
---
 ...020_AddCatalogManagePermission.Designer.cs | 334 ++++++++++++++++++
 ...260527101020_AddCatalogManagePermission.cs |  34 ++
 2 files changed, 368 insertions(+)
 create mode 100644 src/Modules/Users/Eternelle.Modules.Users.Infrastructure/Database/Migrations/20260527101020_AddCatalogManagePermission.Designer.cs
 create mode 100644 src/Modules/Users/Eternelle.Modules.Users.Infrastructure/Database/Migrations/20260527101020_AddCatalogManagePermission.cs

diff --git a/src/Modules/Users/Eternelle.Modules.Users.Infrastructure/Database/Migrations/20260527101020_AddCatalogManagePermission.Designer.cs b/src/Modules/Users/Eternelle.Modules.Users.Infrastructure/Database/Migrations/20260527101020_AddCatalogManagePermission.Designer.cs
new file mode 100644
index 0000000..cd54970
--- /dev/null
+++ b/src/Modules/Users/Eternelle.Modules.Users.Infrastructure/Database/Migrations/20260527101020_AddCatalogManagePermission.Designer.cs
@@ -0,0 +1,334 @@
+// <auto-generated />
+using System;
+using Eternelle.Modules.Users.Infrastructure.Database;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+
+#nullable disable
+
+namespace Eternelle.Modules.Users.Infrastructure.Database.Migrations
+{
+    [DbContext(typeof(UsersDbContext))]
+    [Migration("20260527101020_AddCatalogManagePermission")]
+    partial class AddCatalogManagePermission
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasDefaultSchema("users")
+                .HasAnnotation("ProductVersion", "10.0.4")
+                .HasAnnotation("Relational:MaxIdentifierLength", 63);
+
+            NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
+
+            modelBuilder.Entity("Eternelle.Common.Infrastructure.Inbox.InboxMessage", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid")
+                        .HasColumnName("id");
+
+                    b.Property<string>("Content")
+                        .IsRequired()
+                        .HasMaxLength(2000)
+                        .HasColumnType("jsonb")
+                        .HasColumnName("content");
+
+                    b.Property<string>("Error")
+                        .HasColumnType("text")
+                        .HasColumnName("error");
+
+                    b.Property<DateTime>("OccurredOnUtc")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("occurred_on_utc");
+
+                    b.Property<DateTime?>("ProcessedOnUtc")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("processed_on_utc");
+
+                    b.Property<string>("Type")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("type");
+
+                    b.HasKey("Id")
+                        .HasName("pk_inbox_messages");
+
+                    b.ToTable("inbox_messages", "users");
+                });
+
+            modelBuilder.Entity("Eternelle.Common.Infrastructure.Inbox.InboxMessageConsumer", b =>
+                {
+                    b.Property<Guid>("InboxMessageId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("inbox_message_id");
+
+                    b.Property<string>("Name")
+                        .HasMaxLength(500)
+                        .HasColumnType("character varying(500)")
+                        .HasColumnName("name");
+
+                    b.HasKey("InboxMessageId", "Name")
+                        .HasName("pk_inbox_message_consumers");
+
+                    b.ToTable("inbox_message_consumers", "users");
+                });
+
+            modelBuilder.Entity("Eternelle.Common.Infrastructure.Outbox.OutboxMessage", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid")
+                        .HasColumnName("id");
+
+                    b.Property<string>("Content")
+                        .IsRequired()
+                        .HasMaxLength(2000)
+                        .HasColumnType("jsonb")
+                        .HasColumnName("content");
+
+                    b.Property<string>("Error")
+                        .HasColumnType("text")
+                        .HasColumnName("error");
+
+                    b.Property<DateTime>("OccurredOnUtc")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("occurred_on_utc");
+
+                    b.Property<DateTime?>("ProcessedOnUtc")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("processed_on_utc");
+
+                    b.Property<string>("Type")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("type");
+
+                    b.HasKey("Id")
+                        .HasName("pk_outbox_messages");
+
+                    b.ToTable("outbox_messages", "users");
+                });
+
+            modelBuilder.Entity("Eternelle.Common.Infrastructure.Outbox.OutboxMessageConsumer", b =>
+                {
+                    b.Property<Guid>("OutboxMessageId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("outbox_message_id");
+
+                    b.Property<string>("Name")
+                        .HasMaxLength(500)
+                        .HasColumnType("character varying(500)")
+                        .HasColumnName("name");
+
+                    b.HasKey("OutboxMessageId", "Name")
+                        .HasName("pk_outbox_message_consumers");
+
+                    b.ToTable("outbox_message_consumers", "users");
+                });
+
+            modelBuilder.Entity("Eternelle.Modules.Users.Domain.Users.Permission", b =>
+                {
+                    b.Property<string>("Code")
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)")
+                        .HasColumnName("code");
+
+                    b.HasKey("Code")
+                        .HasName("pk_permissions");
+
+                    b.ToTable("permissions", "users");
+
+                    b.HasData(
+                        new
+                        {
+                            Code = "users:read"
+                        },
+                        new
+                        {
+                            Code = "users:update"
+                        });
+                });
+
+            modelBuilder.Entity("Eternelle.Modules.Users.Domain.Users.Role", b =>
+                {
+                    b.Property<string>("Name")
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)")
+                        .HasColumnName("name");
+
+                    b.HasKey("Name")
+                        .HasName("pk_roles");
+
+                    b.ToTable("roles", "users");
+
+                    b.HasData(
+                        new
+                        {
+                            Name = "Admin"
+                        },
+                        new
+                        {
+                            Name = "Couple"
+                        },
+                        new
+                        {
+                            Name = "Guest"
+                        });
+                });
+
+            modelBuilder.Entity("Eternelle.Modules.Users.Domain.Users.User", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid")
+                        .HasColumnName("id");
+
+                    b.Property<string>("Email")
+                        .IsRequired()
+                        .HasMaxLength(300)
+                        .HasColumnType("character varying(300)")
+                        .HasColumnName("email");
+
+                    b.Property<string>("FirstName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)")
+                        .HasColumnName("first_name");
+
+                    b.Property<string>("IdentityId")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("identity_id");
+
+                    b.Property<string>("LastName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)")
+                        .HasColumnName("last_name");
+
+                    b.Property<string>("PhoneNumber")
+                        .HasMaxLength(16)
+                        .HasColumnType("character varying(16)")
+                        .HasColumnName("phone_number");
+
+                    b.HasKey("Id")
+                        .HasName("pk_users");
+
+                    b.HasIndex("Email")
+                        .IsUnique()
+                        .HasDatabaseName("ix_users_email");
+
+                    b.HasIndex("IdentityId")
+                        .IsUnique()
+                        .HasDatabaseName("ix_users_identity_id");
+
+                    b.ToTable("users", "users");
+                });
+
+            modelBuilder.Entity("PermissionRole", b =>
+                {
+                    b.Property<string>("PermissionCode")
+                        .HasColumnType("character varying(100)")
+                        .HasColumnName("permission_code");
+
+                    b.Property<string>("RoleName")
+                        .HasColumnType("character varying(50)")
+                        .HasColumnName("role_name");
+
+                    b.HasKey("PermissionCode", "RoleName")
+                        .HasName("pk_role_permissions");
+
+                    b.HasIndex("RoleName")
+                        .HasDatabaseName("ix_role_permissions_role_name");
+
+                    b.ToTable("role_permissions", "users");
+
+                    b.HasData(
+                        new
+                        {
+                            PermissionCode = "users:read",
+                            RoleName = "Couple"
+                        },
+                        new
+                        {
+                            PermissionCode = "users:update",
+                            RoleName = "Couple"
+                        },
+                        new
+                        {
+                            PermissionCode = "users:read",
+                            RoleName = "Admin"
+                        },
+                        new
+                        {
+                            PermissionCode = "users:update",
+                            RoleName = "Admin"
+                        },
+                        new
+                        {
+                            PermissionCode = "users:read",
+                            RoleName = "Guest"
+                        });
+                });
+
+            modelBuilder.Entity("RoleUser", b =>
+                {
+                    b.Property<string>("RolesName")
+                        .HasColumnType("character varying(50)")
+                        .HasColumnName("role_name");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("user_id");
+
+                    b.HasKey("RolesName", "UserId")
+                        .HasName("pk_user_roles");
+
+                    b.HasIndex("UserId")
+                        .HasDatabaseName("ix_user_roles_user_id");
+
+                    b.ToTable("user_roles", "users");
+                });
+
+            modelBuilder.Entity("PermissionRole", b =>
+                {
+                    b.HasOne("Eternelle.Modules.Users.Domain.Users.Permission", null)
+                        .WithMany()
+                        .HasForeignKey("PermissionCode")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("fk_role_permissions_permissions_permission_code");
+
+                    b.HasOne("Eternelle.Modules.Users.Domain.Users.Role", null)
+                        .WithMany()
+                        .HasForeignKey("RoleName")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("fk_role_permissions_roles_role_name");
+                });
+
+            modelBuilder.Entity("RoleUser", b =>
+                {
+                    b.HasOne("Eternelle.Modules.Users.Domain.Users.Role", null)
+                        .WithMany()
+                        .HasForeignKey("RolesName")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("fk_user_roles_roles_roles_name");
+
+                    b.HasOne("Eternelle.Modules.Users.Domain.Users.User", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("fk_user_roles_users_user_id");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}
diff --git a/src/Modules/Users/Eternelle.Modules.Users.Infrastructure/Database/Migrations/20260527101020_AddCatalogManagePermission.cs b/src/Modules/Users/Eternelle.Modules.Users.Infrastructure/Database/Migrations/20260527101020_AddCatalogManagePermission.cs
new file mode 100644
index 0000000..b4fdab2
--- /dev/null
+++ b/src/Modules/Users/Eternelle.Modules.Users.Infrastructure/Database/Migrations/20260527101020_AddCatalogManagePermission.cs
@@ -0,0 +1,34 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace Eternelle.Modules.Users.Infrastructure.Database.Migrations;
+
+/// <inheritdoc />
+public partial class AddCatalogManagePermission : Migration
+{
+    /// <inheritdoc />
+    protected override void Up(MigrationBuilder migrationBuilder)
+    {
+        migrationBuilder.Sql(
+            """
+            INSERT INTO users.permissions (code)
+            VALUES ('catalog:manage')
+            ON CONFLICT DO NOTHING;
+
+            INSERT INTO users.role_permissions (permission_code, role_name)
+            VALUES ('catalog:manage', 'Admin')
+            ON CONFLICT DO NOTHING;
+            """);
+    }
+
+    /// <inheritdoc />
+    protected override void Down(MigrationBuilder migrationBuilder)
+    {
+        migrationBuilder.Sql(
+            """
+            DELETE FROM users.role_permissions WHERE permission_code = 'catalog:manage';
+            DELETE FROM users.permissions WHERE code = 'catalog:manage';
+            """);
+    }
+}

From 0d9417399877daca2fa2ee45ef270145bdaf1337 Mon Sep 17 00:00:00 2001
From: Carl Marion <carlmarion.develops@gmail.com>
Date: Wed, 27 May 2026 18:23:03 +0800
Subject: [PATCH 28/31] Eternelle-180 Apply file-scoped namespace and
 collection expression fixes to initial migration

---
 .../20260527094230_InitialCatalog.cs          | 59 +++++++++----------
 1 file changed, 29 insertions(+), 30 deletions(-)

diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Infrastructure/Database/Migrations/20260527094230_InitialCatalog.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Infrastructure/Database/Migrations/20260527094230_InitialCatalog.cs
index ed89e38..c61f666 100644
--- a/src/Modules/Catalog/Eternelle.Modules.Catalog.Infrastructure/Database/Migrations/20260527094230_InitialCatalog.cs
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Infrastructure/Database/Migrations/20260527094230_InitialCatalog.cs
@@ -3,11 +3,11 @@
 
 #nullable disable
 
-namespace Eternelle.Modules.Catalog.Infrastructure.Database.Migrations
+namespace Eternelle.Modules.Catalog.Infrastructure.Database.Migrations;
+
+/// <inheritdoc />
+public partial class InitialCatalog : Migration
 {
-    /// <inheritdoc />
-    public partial class InitialCatalog : Migration
-    {
         /// <inheritdoc />
         protected override void Up(MigrationBuilder migrationBuilder)
         {
@@ -140,14 +140,14 @@ protected override void Up(MigrationBuilder migrationBuilder)
                 name: "ix_template_section_variants_template_id_section_id_variant",
                 schema: "catalog",
                 table: "template_section_variants",
-                columns: new[] { "template_id", "section_id", "variant" },
+                columns: ["template_id", "section_id", "variant"],
                 unique: true);
 
             migrationBuilder.CreateIndex(
                 name: "ux_template_section_variants_one_default",
                 schema: "catalog",
                 table: "template_section_variants",
-                columns: new[] { "template_id", "section_id" },
+                columns: ["template_id", "section_id"],
                 unique: true,
                 filter: "is_default = true");
 
@@ -155,14 +155,14 @@ protected override void Up(MigrationBuilder migrationBuilder)
                 name: "ix_template_supported_sections_template_id_section_id",
                 schema: "catalog",
                 table: "template_supported_sections",
-                columns: new[] { "template_id", "section_id" },
+                columns: ["template_id", "section_id"],
                 unique: true);
 
             migrationBuilder.CreateIndex(
                 name: "ix_template_themes_template_id_theme_index",
                 schema: "catalog",
                 table: "template_themes",
-                columns: new[] { "template_id", "theme_index" },
+                columns: ["template_id", "theme_index"],
                 unique: true);
 
             migrationBuilder.CreateIndex(
@@ -217,32 +217,31 @@ INSERT INTO catalog.template_section_variants (id, template_id, section_id, vari
                 """);
         }
 
-        /// <inheritdoc />
-        protected override void Down(MigrationBuilder migrationBuilder)
-        {
-            migrationBuilder.DropTable(
-                name: "outbox_message_consumers",
-                schema: "catalog");
+    /// <inheritdoc />
+    protected override void Down(MigrationBuilder migrationBuilder)
+    {
+        migrationBuilder.DropTable(
+            name: "outbox_message_consumers",
+            schema: "catalog");
 
-            migrationBuilder.DropTable(
-                name: "outbox_messages",
-                schema: "catalog");
+        migrationBuilder.DropTable(
+            name: "outbox_messages",
+            schema: "catalog");
 
-            migrationBuilder.DropTable(
-                name: "template_section_variants",
-                schema: "catalog");
+        migrationBuilder.DropTable(
+            name: "template_section_variants",
+            schema: "catalog");
 
-            migrationBuilder.DropTable(
-                name: "template_supported_sections",
-                schema: "catalog");
+        migrationBuilder.DropTable(
+            name: "template_supported_sections",
+            schema: "catalog");
 
-            migrationBuilder.DropTable(
-                name: "template_themes",
-                schema: "catalog");
+        migrationBuilder.DropTable(
+            name: "template_themes",
+            schema: "catalog");
 
-            migrationBuilder.DropTable(
-                name: "templates",
-                schema: "catalog");
-        }
+        migrationBuilder.DropTable(
+            name: "templates",
+            schema: "catalog");
     }
 }

From 7ec9a039d925b6f2e3e8cb475527123c30ed9fa6 Mon Sep 17 00:00:00 2001
From: Carl Marion <carlmarion.develops@gmail.com>
Date: Wed, 27 May 2026 18:45:43 +0800
Subject: [PATCH 29/31] Eternelle-180 Add migration support for
 CatalogDbContext

Extended migration logic to include CatalogDbContext alongside WeddingsDbContext and UsersDbContext. Updated imports to reference the Catalog module's DbContext.
---
 src/API/Eternelle.Api/Extensions/MigrationExtensions.cs | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/API/Eternelle.Api/Extensions/MigrationExtensions.cs b/src/API/Eternelle.Api/Extensions/MigrationExtensions.cs
index b56f3b5..0d62e02 100644
--- a/src/API/Eternelle.Api/Extensions/MigrationExtensions.cs
+++ b/src/API/Eternelle.Api/Extensions/MigrationExtensions.cs
@@ -1,3 +1,4 @@
+using Eternelle.Modules.Catalog.Infrastructure.Database;
 using Eternelle.Modules.Users.Infrastructure.Database;
 using Eternelle.Modules.Weddings.Infrastructure.Database;
 using Microsoft.EntityFrameworkCore;
@@ -12,6 +13,7 @@ public static void ApplyMigrations(this IApplicationBuilder app)
 
         ApplyMigration<WeddingsDbContext>(scope);
         ApplyMigration<UsersDbContext>(scope);
+        ApplyMigration<CatalogDbContext>(scope);
     }
 
     private static void ApplyMigration<TDbContext>(IServiceScope scope)

From fef0171d329a53602e3863ea718089526a8fa18b Mon Sep 17 00:00:00 2001
From: Carl Marion <carlmarion.develops@gmail.com>
Date: Wed, 27 May 2026 19:19:40 +0800
Subject: [PATCH 30/31] Eternelle-180 Address code review findings on Template
 aggregate and validators

- Add MaxVariantLength constant to TemplateSectionVariant; reference it
  in AddSectionVariantCommandValidator and EF config (removes magic number)
- Add Textures validation rule in AddTemplateThemeCommandValidator (nullable guard)
- Wrap cache eviction loop in try/catch with ILogger in CreateTemplateCommandHandler
- Defensively copy features collection in Template.Create and UpdateDetails

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 .../AddSectionVariantCommandValidator.cs            |  3 ++-
 .../AddTemplateThemeCommandValidator.cs             |  1 +
 .../CreateTemplate/CreateTemplateCommandHandler.cs  | 13 +++++++++++--
 .../Templates/Template.cs                           |  4 ++--
 .../Templates/TemplateSectionVariant.cs             |  2 ++
 .../TemplateSectionVariantConfiguration.cs          |  2 +-
 6 files changed, 19 insertions(+), 6 deletions(-)

diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/AddSectionVariant/AddSectionVariantCommandValidator.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/AddSectionVariant/AddSectionVariantCommandValidator.cs
index 38957de..f1e3654 100644
--- a/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/AddSectionVariant/AddSectionVariantCommandValidator.cs
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/AddSectionVariant/AddSectionVariantCommandValidator.cs
@@ -1,3 +1,4 @@
+using Eternelle.Modules.Catalog.Domain.Templates;
 using FluentValidation;
 
 namespace Eternelle.Modules.Catalog.Application.Templates.AddSectionVariant;
@@ -8,7 +9,7 @@ public AddSectionVariantCommandValidator()
     {
         RuleFor(c => c.TemplateId).NotEmpty();
         RuleFor(c => c.SectionId).IsInEnum();
-        RuleFor(c => c.Variant).NotEmpty().MaximumLength(100);
+        RuleFor(c => c.Variant).NotEmpty().MaximumLength(TemplateSectionVariant.MaxVariantLength);
         RuleFor(c => c.PriceClass).IsInEnum();
         RuleFor(c => c.UploadLimit).GreaterThan(0).When(c => c.UploadLimit is not null);
     }
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/AddTemplateTheme/AddTemplateThemeCommandValidator.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/AddTemplateTheme/AddTemplateThemeCommandValidator.cs
index 0ec91a8..b135666 100644
--- a/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/AddTemplateTheme/AddTemplateThemeCommandValidator.cs
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/AddTemplateTheme/AddTemplateThemeCommandValidator.cs
@@ -12,5 +12,6 @@ public AddTemplateThemeCommandValidator()
         RuleFor(c => c.Name).NotEmpty().MaximumLength(TemplateThemeName.MaxLength);
         RuleFor(c => c.Colors).NotEmpty();
         RuleFor(c => c.Typography).NotEmpty();
+        RuleFor(c => c.Textures).NotEmpty().When(c => c.Textures is not null);
     }
 }
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/CreateTemplate/CreateTemplateCommandHandler.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/CreateTemplate/CreateTemplateCommandHandler.cs
index bbc812f..375f5fb 100644
--- a/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/CreateTemplate/CreateTemplateCommandHandler.cs
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Application/Templates/CreateTemplate/CreateTemplateCommandHandler.cs
@@ -5,6 +5,7 @@
 using Eternelle.Modules.Catalog.Application.Abstractions.Data;
 using Eternelle.Modules.Catalog.Domain.Shared;
 using Eternelle.Modules.Catalog.Domain.Templates;
+using Microsoft.Extensions.Logging;
 
 namespace Eternelle.Modules.Catalog.Application.Templates.CreateTemplate;
 
@@ -12,7 +13,8 @@ internal sealed class CreateTemplateCommandHandler(
     ITemplateRepository templateRepository,
     IUnitOfWork unitOfWork,
     ICacheService cacheService,
-    IDateTimeProvider dateTimeProvider) : ICommandHandler<CreateTemplateCommand, Guid>
+    IDateTimeProvider dateTimeProvider,
+    ILogger<CreateTemplateCommandHandler> logger) : ICommandHandler<CreateTemplateCommand, Guid>
 {
     public async Task<Result<Guid>> Handle(CreateTemplateCommand command, CancellationToken cancellationToken)
     {
@@ -67,7 +69,14 @@ public async Task<Result<Guid>> Handle(CreateTemplateCommand command, Cancellati
 
         foreach (string key in CatalogCacheKeys.AllTemplateListKeys())
         {
-            await cacheService.RemoveAsync(key, cancellationToken);
+            try
+            {
+                await cacheService.RemoveAsync(key, cancellationToken);
+            }
+            catch (Exception ex)
+            {
+                logger.LogWarning(ex, "Failed to evict cache key '{Key}' after creating template {TemplateId}", key, templateResult.Value.Id.Value);
+            }
         }
 
         return templateResult.Value.Id.Value;
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/Template.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/Template.cs
index 8115272..d7640b8 100644
--- a/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/Template.cs
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/Template.cs
@@ -39,7 +39,7 @@ public static Result<Template> Create(
             Description = description,
             Tier = tier,
             PreviewImageUrl = previewImageUrl,
-            Features = features,
+            Features = [..features],
             CreatedAtUtc = utcNow,
             UpdatedAtUtc = utcNow
         };
@@ -60,7 +60,7 @@ public Result UpdateDetails(
         Name = name;
         Description = description;
         PreviewImageUrl = previewImageUrl;
-        Features = features;
+        Features = [..features];
         UpdatedAtUtc = utcNow;
 
         Raise(BuildManifestEvent());
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/TemplateSectionVariant.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/TemplateSectionVariant.cs
index a191bbe..9299a6b 100644
--- a/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/TemplateSectionVariant.cs
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/TemplateSectionVariant.cs
@@ -4,6 +4,8 @@ namespace Eternelle.Modules.Catalog.Domain.Templates;
 
 public sealed class TemplateSectionVariant : Entity
 {
+    public const int MaxVariantLength = 100;
+
     private TemplateSectionVariant() { }
 
     public TemplateSectionVariantId Id { get; private set; }
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Infrastructure/Templates/TemplateSectionVariantConfiguration.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Infrastructure/Templates/TemplateSectionVariantConfiguration.cs
index c285e95..bea4581 100644
--- a/src/Modules/Catalog/Eternelle.Modules.Catalog.Infrastructure/Templates/TemplateSectionVariantConfiguration.cs
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Infrastructure/Templates/TemplateSectionVariantConfiguration.cs
@@ -18,7 +18,7 @@ public void Configure(EntityTypeBuilder<TemplateSectionVariant> builder)
             .IsRequired()
             .HasMaxLength(50);
 
-        builder.Property(v => v.Variant).IsRequired().HasMaxLength(100);
+        builder.Property(v => v.Variant).IsRequired().HasMaxLength(TemplateSectionVariant.MaxVariantLength);
 
         builder.Property(v => v.IsDefault).IsRequired();
 

From 8169c198d18df4c8449eeff004c971bc2501a50a Mon Sep 17 00:00:00 2001
From: Carl Marion <carlmarion.develops@gmail.com>
Date: Wed, 27 May 2026 21:05:46 +0800
Subject: [PATCH 31/31] Eternelle-180 Refactor init patterns, migrations, and
 add comments

Updated TemplateManifestChangedDomainEvent to use collection expressions for property initialization. Added comments on null! usage in TemplateSectionVariant and TemplateTheme for clarity. Adjusted timestamp handling in InitialCatalog migration to use now(). Limited role_permissions deletion to 'Admin' in AddCatalogManagePermission Down migration.
---
 .../Templates/TemplateManifestChangedDomainEvent.cs           | 4 ++--
 .../Templates/TemplateSectionVariant.cs                       | 2 +-
 .../Templates/TemplateTheme.cs                                | 1 +
 .../Database/Migrations/20260527094230_InitialCatalog.cs      | 4 ++--
 .../Migrations/20260527101020_AddCatalogManagePermission.cs   | 3 +--
 5 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/TemplateManifestChangedDomainEvent.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/TemplateManifestChangedDomainEvent.cs
index 9e5d4fc..17ba61f 100644
--- a/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/TemplateManifestChangedDomainEvent.cs
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/TemplateManifestChangedDomainEvent.cs
@@ -12,6 +12,6 @@ public sealed class TemplateManifestChangedDomainEvent(
     public TemplateId TemplateId { get; init; } = templateId;
     public string Name { get; init; } = name;
     public string Tier { get; init; } = tier;
-    public IReadOnlyList<string> SectionIds { get; init; } = sectionIds;
-    public IReadOnlyList<TemplateManifestItem> Variants { get; init; } = variants;
+    public IReadOnlyList<string> SectionIds { get; init; } = [..sectionIds];
+    public IReadOnlyList<TemplateManifestItem> Variants { get; init; } = [..variants];
 }
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/TemplateSectionVariant.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/TemplateSectionVariant.cs
index 9299a6b..29d42e5 100644
--- a/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/TemplateSectionVariant.cs
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/TemplateSectionVariant.cs
@@ -11,7 +11,7 @@ private TemplateSectionVariant() { }
     public TemplateSectionVariantId Id { get; private set; }
     public TemplateId TemplateId { get; private set; }
     public SectionId SectionId { get; private set; }
-    public string Variant { get; private set; } = null!;
+    public string Variant { get; private set; } = null!; // always set via Create() factory before exposure
     public bool IsDefault { get; private set; }
     public PriceClass PriceClass { get; private set; }
 
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/TemplateTheme.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/TemplateTheme.cs
index 15c66df..0021eab 100644
--- a/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/TemplateTheme.cs
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Domain/Templates/TemplateTheme.cs
@@ -9,6 +9,7 @@ private TemplateTheme() { }
     public TemplateThemeId Id { get; private set; }
     public TemplateId TemplateId { get; private set; }
     public int ThemeIndex { get; private set; }
+    // null! is safe: all three are set before exposure via Create() or EF Core materialization
     public TemplateThemeName Name { get; private set; } = null!;
     public ThemeColors Colors { get; private set; } = null!;
     public ThemeTypography Typography { get; private set; } = null!;
diff --git a/src/Modules/Catalog/Eternelle.Modules.Catalog.Infrastructure/Database/Migrations/20260527094230_InitialCatalog.cs b/src/Modules/Catalog/Eternelle.Modules.Catalog.Infrastructure/Database/Migrations/20260527094230_InitialCatalog.cs
index c61f666..67c9429 100644
--- a/src/Modules/Catalog/Eternelle.Modules.Catalog.Infrastructure/Database/Migrations/20260527094230_InitialCatalog.cs
+++ b/src/Modules/Catalog/Eternelle.Modules.Catalog.Infrastructure/Database/Migrations/20260527094230_InitialCatalog.cs
@@ -182,8 +182,8 @@ INSERT INTO catalog.templates (id, name, description, tier, preview_image_url, f
                     'FirstClass',
                     NULL,
                     '[]'::jsonb,
-                    now() AT TIME ZONE 'utc',
-                    now() AT TIME ZONE 'utc');
+                    now(),
+                    now());
 
                 INSERT INTO catalog.template_themes (id, template_id, theme_index, name, colors, typography, textures, is_dark)
                 VALUES
diff --git a/src/Modules/Users/Eternelle.Modules.Users.Infrastructure/Database/Migrations/20260527101020_AddCatalogManagePermission.cs b/src/Modules/Users/Eternelle.Modules.Users.Infrastructure/Database/Migrations/20260527101020_AddCatalogManagePermission.cs
index b4fdab2..0aa869d 100644
--- a/src/Modules/Users/Eternelle.Modules.Users.Infrastructure/Database/Migrations/20260527101020_AddCatalogManagePermission.cs
+++ b/src/Modules/Users/Eternelle.Modules.Users.Infrastructure/Database/Migrations/20260527101020_AddCatalogManagePermission.cs
@@ -27,8 +27,7 @@ protected override void Down(MigrationBuilder migrationBuilder)
     {
         migrationBuilder.Sql(
             """
-            DELETE FROM users.role_permissions WHERE permission_code = 'catalog:manage';
-            DELETE FROM users.permissions WHERE code = 'catalog:manage';
+            DELETE FROM users.role_permissions WHERE permission_code = 'catalog:manage' AND role_name = 'Admin';
             """);
     }
 }