many fixes and improvements - rework for modules/ and common/

feat(emailer): add Postmark and Resend providers

backend/Modules/Contents/Data/Album.cs

@@ -0,0 +1,11 @@
+using System.ComponentModel.DataAnnotations;
+using Hutopy.Common.Domain;
+
+namespace Hutopy.Modules.Contents.Data;
+
+public class Album : Entity
+{
+    public bool IsDeleted { get; private set; }   // private set → EF updates it
+    [MaxLength(255)] public required string Title { get; set; }
+    public IList<AlbumPhoto> Photos { get; set; } = new List<AlbumPhoto>();
+}

backend/Modules/Contents/Data/AlbumPhoto.cs

@@ -0,0 +1,15 @@
+using System.ComponentModel.DataAnnotations;
+using Hutopy.Common.Domain;
+
+namespace Hutopy.Modules.Contents.Data;
+
+public class AlbumPhoto : Entity
+{
+    public bool IsDeleted { get; private set; } // private set → EF updates it
+    public Guid AlbumId { get; set; }
+    public Album Album { get; init; } = null!;
+    [MaxLength(2048)] public required string OriginalUrl { get; set; }
+    [MaxLength(2048)] public required string ThumbnailUrl { get; set; }
+    [MaxLength(256)] public string? Caption { get; set; }
+    public int Order { get; set; }
+}

backend/Modules/Contents/Data/ContentsDbContext.cs

@@ -0,0 +1,56 @@
+namespace Hutopy.Modules.Contents.Data;
+
+public class ContentsDbContext(
+    DbContextOptions<ContentsDbContext> options)
+    : DbContext(options)
+{
+    public const string SchemaName = "Content";
+
+    public DbSet<Album> Albums => Set<Album>();
+    public DbSet<AlbumPhoto> AlbumPhotos => Set<AlbumPhoto>();
+
+    protected override void OnModelCreating(
+        ModelBuilder modelBuilder)
+    {
+        modelBuilder.HasDefaultSchema(SchemaName);
+
+        // Album configuration
+        modelBuilder
+            .Entity<Album>()
+            .Property(c => c.CreatedAt)
+            .ValueGeneratedOnAdd()
+            .HasDefaultValueSql("CURRENT_TIMESTAMP");
+
+        modelBuilder
+            .Entity<Album>()
+            .Property(c => c.IsDeleted)
+            .HasComputedColumnSql("\"DeletedAt\" IS NOT NULL", stored: true);
+
+        modelBuilder
+            .Entity<Album>()
+            .HasQueryFilter(a => !a.IsDeleted);
+
+        // AlbumPhoto configuration
+        modelBuilder
+            .Entity<AlbumPhoto>()
+            .Property(c => c.CreatedAt)
+            .ValueGeneratedOnAdd()
+            .HasDefaultValueSql("CURRENT_TIMESTAMP");
+
+        modelBuilder
+            .Entity<AlbumPhoto>()
+            .Property(c => c.IsDeleted)
+            .HasComputedColumnSql("\"DeletedAt\" IS NOT NULL", stored: true);
+
+        modelBuilder
+            .Entity<AlbumPhoto>()
+            .HasOne(ap => ap.Album)
+            .WithMany(a => a.Photos)
+            .HasForeignKey(ap => ap.AlbumId)
+            .IsRequired();
+
+        modelBuilder
+            .Entity<AlbumPhoto>()
+            .HasQueryFilter(ap => !ap.IsDeleted);
+    }
+}

backend/Modules/Contents/DependencyInjection.cs

@@ -0,0 +1,27 @@
+using Hutopy.Modules.Contents.Data;
+
+namespace Hutopy.Modules.Contents;
+
+public static class DependencyInjection
+{
+    public static WebApplicationBuilder AddContentModule(
+        this WebApplicationBuilder builder,
+        Action<DbContextOptionsBuilder>? configureAction = null)
+    {
+        builder.Services.AddDbContext<ContentsDbContext>(configureAction);
+
+        return builder;
+    }
+
+    public static async Task<IApplicationBuilder> UseContentModuleAsync(
+        this IApplicationBuilder app,
+        CancellationToken cancellationToken = default)
+    {
+        var scopeFactory = app.ApplicationServices.GetRequiredService<IServiceScopeFactory>();
+        using var scope = scopeFactory.CreateScope();
+        await using var context = scope.ServiceProvider.GetRequiredService<ContentsDbContext>();
+        await context.Database.MigrateAsync(cancellationToken);
+
+        return app;
+    }
+}

backend/Modules/Contents/Features/AddPhotoToAlbum.cs

@@ -0,0 +1,194 @@
+using Hutopy.Infrastructure.BlobStorage.Contracts;
+using Hutopy.Infrastructure.Security;
+using Hutopy.Modules.Contents.Data;
+using SixLabors.ImageSharp;
+using SixLabors.ImageSharp.Processing;
+
+namespace Hutopy.Modules.Contents.Features;
+
+[PublicAPI]
+public record AddPhotoToAlbumRequest(
+    Guid AlbumId,
+    Guid PhotoId,
+    IFormFile File,
+    string? Caption = null);
+
+[PublicAPI]
+public record AddPhotoToAlbumResponse(
+    Guid PhotoId,
+    string OriginalUrl,
+    string ThumbnailUrl);
+
+[PublicAPI]
+public sealed class AddPhotoToAlbumRequestValidator : Validator<AddPhotoToAlbumRequest>
+{
+    private const int MaxFileSizeBytes = 10 * 1024 * 1024; // 10MB
+    private static readonly string[] AllowedImageTypes =
+    [
+        "image/jpeg",
+        "image/png",
+        "image/gif",
+        "image/webp"
+    ];
+
+    public AddPhotoToAlbumRequestValidator()
+    {
+        RuleFor(x => x.AlbumId)
+            .NotNull()
+            .NotEmpty();
+
+        RuleFor(x => x.PhotoId)
+            .NotNull()
+            .NotEmpty();
+
+        RuleFor(x => x.File)
+            .NotNull()
+            .NotEmpty()
+            .Must(file => AllowedImageTypes.Contains(file.ContentType))
+            .WithMessage("File must be a valid image (JPEG, PNG, GIF, or WebP)")
+            .Must(file => file.Length <= MaxFileSizeBytes)
+            .WithMessage($"File size must not exceed {MaxFileSizeBytes / 1024 / 1024}MB");
+
+        RuleFor(x => x.Caption)
+            .MaximumLength(255);
+    }
+}
+
+[PublicAPI]
+public class AddPhotoToAlbumHandler(
+    ContentsDbContext context,
+    IBlobStorage blobStorage)
+    : Endpoint<AddPhotoToAlbumRequest, AddPhotoToAlbumResponse>
+{
+    private const int MaxThumbnailWidth = 500;
+    private const int MaxThumbnailHeight = 500;
+
+    public override void Configure()
+    {
+        Post("/api/albums/{AlbumId}/photos");
+        Options(o => o.WithTags("Albums"));
+        AllowFileUploads();
+    }
+
+    public override async Task HandleAsync(
+        AddPhotoToAlbumRequest request,
+        CancellationToken ct)
+    {
+        var userId = User.GetUserId();
+
+        // Fetch the album we want to add photos to
+        var album = await context
+            .Albums
+            .SingleOrDefaultAsync(
+                a => a.Id == request.AlbumId && a.CreatedBy == userId,
+                cancellationToken: ct);
+
+        if (album is null)
+        {
+            await SendNotFoundAsync(ct);
+            return;
+        }
+
+        // Check if a photo with the same ID already exists
+        var existingPhoto = await context
+            .AlbumPhotos
+            .AnyAsync(p => p.Id == request.PhotoId, ct);
+
+        if (existingPhoto)
+        {
+            await SendErrorsAsync(409, ct);
+            return;
+        }
+
+        try
+        {
+            var (originalUrl, thumbnailUrl) = await ProcessAndUploadImage(request, ct);
+
+            // Get the next order number
+            var nextOrder = await context
+                .AlbumPhotos
+                .Where(p => p.AlbumId == request.AlbumId)
+                .MaxAsync(p => (int?)p.Order, ct) ?? 0;
+
+            // Create the album photo
+            var photo = new AlbumPhoto
+            {
+                Id = request.PhotoId,
+                CreatedBy = userId,
+                AlbumId = request.AlbumId,
+                OriginalUrl = originalUrl,
+                ThumbnailUrl = thumbnailUrl,
+                Caption = request.Caption,
+                Order = nextOrder + 1
+            };
+
+            context.AlbumPhotos.Add(photo);
+            await context.SaveChangesAsync(ct);
+
+            await SendOkAsync(
+                new AddPhotoToAlbumResponse(photo.Id, originalUrl, thumbnailUrl),
+                ct);
+        }
+        catch (UnknownImageFormatException)
+        {
+            await SendStringAsync("Invalid image format", 400, cancellation: ct);
+        }
+        catch (Exception)
+        {
+            await SendStringAsync("Error processing image", 500, cancellation: ct);
+        }
+    }
+
+    private async Task<(string originalUrl, string thumbnailUrl)> ProcessAndUploadImage(
+        AddPhotoToAlbumRequest request,
+        CancellationToken ct)
+    {
+        var originalFileName = Path.GetFileName(request.File.FileName);
+        var nameWithoutExt = Path.GetFileNameWithoutExtension(originalFileName);
+        var extension = Path.GetExtension(originalFileName);
+
+        var filenameOriginal = $"{nameWithoutExt}{extension}";
+        var filenameThumbnail = $"{nameWithoutExt}.thumbnail{extension}";
+
+        var blobOriginal = $"{SubDirectoryNames.Albums}/{request.AlbumId}/{filenameOriginal}";
+        var blobThumbnail = $"{SubDirectoryNames.Albums}/{request.AlbumId}/{filenameThumbnail}";
+
+        // Process the original image
+        await using var originalStream = request.File.OpenReadStream();
+        using var image = await Image.LoadAsync(originalStream, ct);
+
+        // Calculate target size while preserving the original aspect ratio
+        var originalWidth = image.Width;
+        var originalHeight = image.Height;
+
+        double ratioX = (double)MaxThumbnailWidth / originalWidth;
+        double ratioY = (double)MaxThumbnailHeight / originalHeight;
+        double ratio = Math.Min(ratioX, ratioY);
+
+        int newWidth = (int)(originalWidth * ratio);
+        int newHeight = (int)(originalHeight * ratio);
+
+        // Create thumbnail
+        using var thumbnailStream = new MemoryStream();
+        image.Mutate(x => x.Resize(newWidth, newHeight));
+        await image.SaveAsync(thumbnailStream, image.Metadata.DecodedImageFormat!, ct);
+        thumbnailStream.Position = 0;
+
+        // Upload both versions
+        var originalUrl = await blobStorage.UploadFileAsync(
+            ContainerNames.Creators,
+            blobOriginal,
+            request.File.OpenReadStream(),
+            request.File.ContentType,
+            ct);
+
+        var thumbnailUrl = await blobStorage.UploadFileAsync(
+            ContainerNames.Creators,
+            blobThumbnail,
+            thumbnailStream,
+            request.File.ContentType,
+            ct);
+
+        return (originalUrl, thumbnailUrl);
+    }
+}

backend/Modules/Contents/Features/CreateAlbum.cs

@@ -0,0 +1,75 @@
+using Hutopy.Infrastructure.Security;
+using Hutopy.Modules.Contents.Data;
+
+namespace Hutopy.Modules.Contents.Features;
+
+[PublicAPI]
+public record CreateAlbumRequest(
+    Guid AlbumId,
+    string Title,
+    string? Description = null);
+
+[PublicAPI]
+public record CreateAlbumResponse(
+    Guid AlbumId);
+
+[PublicAPI]
+public sealed class CreateAlbumRequestValidator : Validator<CreateAlbumRequest>
+{
+    public CreateAlbumRequestValidator()
+    {
+        RuleFor(x => x.AlbumId)
+            .NotNull()
+            .NotEmpty();
+
+        RuleFor(x => x.Title)
+            .NotNull()
+            .NotEmpty()
+            .MaximumLength(255);
+
+        RuleFor(x => x.Description)
+            .MaximumLength(1000);
+    }
+}
+
+[PublicAPI]
+public class CreateAlbumHandler(
+    ContentsDbContext context)
+    : Endpoint<CreateAlbumRequest, CreateAlbumResponse>
+{
+    public override void Configure()
+    {
+        Post("/api/albums");
+        Options(o => o.WithTags("Albums"));
+    }
+
+    public override async Task HandleAsync(
+        CreateAlbumRequest request,
+        CancellationToken ct)
+    {
+        // Check if an album with the same ID already exists
+        var existingAlbum = await context
+            .Albums
+            .AnyAsync(a => a.Id == request.AlbumId, ct);
+
+        if (existingAlbum)
+        {
+            await SendErrorsAsync(409, ct);
+            return;
+        }
+
+        var album = new Album
+        {
+            Id = request.AlbumId,
+            CreatedBy = User.GetUserId(),
+            Title = request.Title
+        };
+
+        context.Albums.Add(album);
+        await context.SaveChangesAsync(ct);
+
+        await SendOkAsync(
+            new CreateAlbumResponse(album.Id),
+            ct);
+    }
+} 

backend/Modules/Contents/Features/GetAlbum.cs

@@ -0,0 +1,83 @@
+using Hutopy.Modules.Contents.Data;
+
+namespace Hutopy.Modules.Contents.Features;
+
+[PublicAPI]
+public record GetAlbumRequest(
+    Guid AlbumId);
+
+[PublicAPI]
+public record AlbumPhotoDto(
+    Guid Id,
+    string OriginalUrl,
+    string ThumbnailUrl,
+    string? Caption,
+    int Order,
+    DateTimeOffset CreatedAt);
+
+[PublicAPI]
+public record GetAlbumResponse(
+    Guid Id,
+    string Title,
+    IReadOnlyList<AlbumPhotoDto> Photos,
+    DateTimeOffset CreatedAt);
+
+[PublicAPI]
+public sealed class GetAlbumRequestValidator : Validator<GetAlbumRequest>
+{
+    public GetAlbumRequestValidator()
+    {
+        RuleFor(x => x.AlbumId)
+            .NotNull()
+            .NotEmpty();
+    }
+}
+
+[PublicAPI]
+public class GetAlbumHandler(
+    ContentsDbContext context)
+    : Endpoint<GetAlbumRequest, GetAlbumResponse>
+{
+    public override void Configure()
+    {
+        AllowAnonymous();
+        Get("/api/albums/{AlbumId}");
+        Options(o => o.WithTags("Albums"));
+    }
+
+    public override async Task HandleAsync(
+        GetAlbumRequest request,
+        CancellationToken ct)
+    {
+        var album = await context
+            .Albums
+            .Include(a => a.Photos.OrderBy(p => p.Order))
+            .SingleOrDefaultAsync(
+                a => a.Id == request.AlbumId,
+                cancellationToken: ct);
+
+        if (album is null)
+        {
+            await SendNotFoundAsync(ct);
+            return;
+        }
+
+        var photos = album.Photos
+            .Select(p => new AlbumPhotoDto(
+                p.Id,
+                p.OriginalUrl,
+                p.ThumbnailUrl,
+                p.Caption,
+                p.Order,
+                p.CreatedAt))
+            .ToList();
+
+        await SendOkAsync(
+            new GetAlbumResponse(
+                album.Id,
+                album.Title,
+                photos,
+                album.CreatedAt),
+            ct);
+    }
+}

backend/Modules/Contents/Features/RemoveAlbum.cs

@@ -0,0 +1,66 @@
+using Hutopy.Infrastructure.Security;
+using Hutopy.Modules.Contents.Data;
+
+namespace Hutopy.Modules.Contents.Features;
+
+[PublicAPI]
+public record RemoveAlbumRequest(
+    Guid AlbumId);
+
+[PublicAPI]
+public sealed class RemoveAlbumRequestValidator : Validator<RemoveAlbumRequest>
+{
+    public RemoveAlbumRequestValidator()
+    {
+        RuleFor(x => x.AlbumId)
+            .NotNull()
+            .NotEmpty();
+    }
+}
+
+[PublicAPI]
+public class RemoveAlbumHandler(
+    ContentsDbContext context)
+    : Endpoint<RemoveAlbumRequest>
+{
+    public override void Configure()
+    {
+        Delete("/api/albums/{AlbumId}");
+        Options(o => o.WithTags("Albums"));
+    }
+
+    public override async Task HandleAsync(
+        RemoveAlbumRequest request,
+        CancellationToken ct)
+    {
+        var userId = User.GetUserId();
+
+        var album = await context
+            .Albums
+            .Include(a => a.Photos)
+            .SingleOrDefaultAsync(
+                a => a.Id == request.AlbumId && a.CreatedBy == userId,
+                cancellationToken: ct);
+
+        if (album is null)
+        {
+            await SendNotFoundAsync(ct);
+            return;
+        }
+
+        // Soft delete the album
+        album.DeletedBy = userId;
+        album.DeletedAt = DateTimeOffset.UtcNow;
+
+        // Soft delete all photos in the album
+        foreach (var photo in album.Photos)
+        {
+            photo.DeletedBy = userId;
+            photo.DeletedAt = DateTimeOffset.UtcNow;
+        }
+
+        await context.SaveChangesAsync(ct);
+
+        await SendNoContentAsync(ct);
+    }
+} 

backend/Modules/Contents/Features/RemovePhotoFromAlbum.cs

@@ -0,0 +1,73 @@
+using Hutopy.Infrastructure.Security;
+using Hutopy.Modules.Contents.Data;
+
+namespace Hutopy.Modules.Contents.Features;
+
+[PublicAPI]
+public record RemovePhotoFromAlbumRequest(
+    Guid AlbumId,
+    Guid PhotoId);
+
+[PublicAPI]
+public sealed class RemovePhotoFromAlbumRequestValidator : Validator<RemovePhotoFromAlbumRequest>
+{
+    public RemovePhotoFromAlbumRequestValidator()
+    {
+        RuleFor(x => x.AlbumId)
+            .NotNull()
+            .NotEmpty();
+
+        RuleFor(x => x.PhotoId)
+            .NotNull()
+            .NotEmpty();
+    }
+}
+
+[PublicAPI]
+public class RemovePhotoFromAlbumHandler(
+    ContentsDbContext context)
+    : Endpoint<RemovePhotoFromAlbumRequest>
+{
+    public override void Configure()
+    {
+        Delete("/api/albums/{AlbumId}/photos/{PhotoId}");
+        Options(o => o.WithTags("Albums"));
+    }
+
+    public override async Task HandleAsync(
+        RemovePhotoFromAlbumRequest request,
+        CancellationToken ct)
+    {
+        var userId = User.GetUserId();
+
+        var album = await context
+            .Albums
+            .Include(a => a.Photos)
+            .SingleOrDefaultAsync(
+                a => a.Id == request.AlbumId && a.CreatedBy == userId,
+                cancellationToken: ct);
+
+        if (album is null)
+        {
+            await SendNotFoundAsync(ct);
+            return;
+        }
+
+        var photo = album.Photos
+            .SingleOrDefault(p => p.Id == request.PhotoId);
+
+        if (photo is null)
+        {
+            await SendNotFoundAsync(ct);
+            return;
+        }
+
+        // Soft delete the photo
+        photo.DeletedBy = userId;
+        photo.DeletedAt = DateTimeOffset.UtcNow;
+        
+        await context.SaveChangesAsync(ct);
+
+        await SendNoContentAsync(ct);
+    }
+} 

backend/Modules/Contents/Migrations/20250609212411_Initial.Designer.cs

@@ -0,0 +1,134 @@
+// <auto-generated />
+using System;
+using Hutopy.Modules.Contents.Data;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+
+#nullable disable
+
+namespace Hutopy.Modules.Contents.Migrations
+{
+    [DbContext(typeof(ContentsDbContext))]
+    [Migration("20250609212411_Initial")]
+    partial class Initial
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasDefaultSchema("Content")
+                .HasAnnotation("ProductVersion", "9.0.3")
+                .HasAnnotation("Relational:MaxIdentifierLength", 63);
+
+            NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
+
+            modelBuilder.Entity("Hutopy.Modules.Contents.Data.Album", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("CURRENT_TIMESTAMP");
+
+                    b.Property<Guid>("CreatedBy")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset?>("DeletedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<Guid?>("DeletedBy")
+                        .HasColumnType("uuid");
+
+                    b.Property<bool>("IsDeleted")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("boolean")
+                        .HasComputedColumnSql("\"DeletedAt\" IS NOT NULL", true);
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasMaxLength(255)
+                        .HasColumnType("character varying(255)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Albums", "Content");
+                });
+
+            modelBuilder.Entity("Hutopy.Modules.Contents.Data.AlbumPhoto", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("AlbumId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Caption")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("CURRENT_TIMESTAMP");
+
+                    b.Property<Guid>("CreatedBy")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset?>("DeletedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<Guid?>("DeletedBy")
+                        .HasColumnType("uuid");
+
+                    b.Property<bool>("IsDeleted")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("boolean")
+                        .HasComputedColumnSql("\"DeletedAt\" IS NOT NULL", true);
+
+                    b.Property<int>("Order")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("OriginalUrl")
+                        .IsRequired()
+                        .HasMaxLength(2048)
+                        .HasColumnType("character varying(2048)");
+
+                    b.Property<string>("ThumbnailUrl")
+                        .IsRequired()
+                        .HasMaxLength(2048)
+                        .HasColumnType("character varying(2048)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AlbumId");
+
+                    b.ToTable("AlbumPhotos", "Content");
+                });
+
+            modelBuilder.Entity("Hutopy.Modules.Contents.Data.AlbumPhoto", b =>
+                {
+                    b.HasOne("Hutopy.Modules.Contents.Data.Album", "Album")
+                        .WithMany("Photos")
+                        .HasForeignKey("AlbumId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Album");
+                });
+
+            modelBuilder.Entity("Hutopy.Modules.Contents.Data.Album", b =>
+                {
+                    b.Navigation("Photos");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

backend/Modules/Contents/Migrations/20250609212411_Initial.cs

@@ -0,0 +1,83 @@
+using System;
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace Hutopy.Modules.Contents.Migrations
+{
+    /// <inheritdoc />
+    public partial class Initial : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.EnsureSchema(
+                name: "Content");
+
+            migrationBuilder.CreateTable(
+                name: "Albums",
+                schema: "Content",
+                columns: table => new
+                {
+                    Id = table.Column<Guid>(type: "uuid", nullable: false),
+                    IsDeleted = table.Column<bool>(type: "boolean", nullable: false, computedColumnSql: "\"DeletedAt\" IS NOT NULL", stored: true),
+                    Title = table.Column<string>(type: "character varying(255)", maxLength: 255, nullable: false),
+                    CreatedBy = table.Column<Guid>(type: "uuid", nullable: false),
+                    CreatedAt = table.Column<DateTimeOffset>(type: "timestamp with time zone", nullable: false, defaultValueSql: "CURRENT_TIMESTAMP"),
+                    DeletedBy = table.Column<Guid>(type: "uuid", nullable: true),
+                    DeletedAt = table.Column<DateTimeOffset>(type: "timestamp with time zone", nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_Albums", x => x.Id);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "AlbumPhotos",
+                schema: "Content",
+                columns: table => new
+                {
+                    Id = table.Column<Guid>(type: "uuid", nullable: false),
+                    IsDeleted = table.Column<bool>(type: "boolean", nullable: false, computedColumnSql: "\"DeletedAt\" IS NOT NULL", stored: true),
+                    AlbumId = table.Column<Guid>(type: "uuid", nullable: false),
+                    OriginalUrl = table.Column<string>(type: "character varying(2048)", maxLength: 2048, nullable: false),
+                    ThumbnailUrl = table.Column<string>(type: "character varying(2048)", maxLength: 2048, nullable: false),
+                    Caption = table.Column<string>(type: "character varying(256)", maxLength: 256, nullable: true),
+                    Order = table.Column<int>(type: "integer", nullable: false),
+                    CreatedBy = table.Column<Guid>(type: "uuid", nullable: false),
+                    CreatedAt = table.Column<DateTimeOffset>(type: "timestamp with time zone", nullable: false, defaultValueSql: "CURRENT_TIMESTAMP"),
+                    DeletedBy = table.Column<Guid>(type: "uuid", nullable: true),
+                    DeletedAt = table.Column<DateTimeOffset>(type: "timestamp with time zone", nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_AlbumPhotos", x => x.Id);
+                    table.ForeignKey(
+                        name: "FK_AlbumPhotos_Albums_AlbumId",
+                        column: x => x.AlbumId,
+                        principalSchema: "Content",
+                        principalTable: "Albums",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateIndex(
+                name: "IX_AlbumPhotos_AlbumId",
+                schema: "Content",
+                table: "AlbumPhotos",
+                column: "AlbumId");
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropTable(
+                name: "AlbumPhotos",
+                schema: "Content");
+
+            migrationBuilder.DropTable(
+                name: "Albums",
+                schema: "Content");
+        }
+    }
+}

backend/Modules/Contents/Migrations/ContentsDbContextModelSnapshot.cs

@@ -0,0 +1,131 @@
+// <auto-generated />
+using System;
+using Hutopy.Modules.Contents.Data;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+
+#nullable disable
+
+namespace Hutopy.Modules.Contents.Migrations
+{
+    [DbContext(typeof(ContentsDbContext))]
+    partial class ContentsDbContextModelSnapshot : ModelSnapshot
+    {
+        protected override void BuildModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasDefaultSchema("Content")
+                .HasAnnotation("ProductVersion", "9.0.3")
+                .HasAnnotation("Relational:MaxIdentifierLength", 63);
+
+            NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
+
+            modelBuilder.Entity("Hutopy.Modules.Contents.Data.Album", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("CURRENT_TIMESTAMP");
+
+                    b.Property<Guid>("CreatedBy")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset?>("DeletedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<Guid?>("DeletedBy")
+                        .HasColumnType("uuid");
+
+                    b.Property<bool>("IsDeleted")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("boolean")
+                        .HasComputedColumnSql("\"DeletedAt\" IS NOT NULL", true);
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasMaxLength(255)
+                        .HasColumnType("character varying(255)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Albums", "Content");
+                });
+
+            modelBuilder.Entity("Hutopy.Modules.Contents.Data.AlbumPhoto", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("AlbumId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Caption")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("CURRENT_TIMESTAMP");
+
+                    b.Property<Guid>("CreatedBy")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset?>("DeletedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<Guid?>("DeletedBy")
+                        .HasColumnType("uuid");
+
+                    b.Property<bool>("IsDeleted")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("boolean")
+                        .HasComputedColumnSql("\"DeletedAt\" IS NOT NULL", true);
+
+                    b.Property<int>("Order")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("OriginalUrl")
+                        .IsRequired()
+                        .HasMaxLength(2048)
+                        .HasColumnType("character varying(2048)");
+
+                    b.Property<string>("ThumbnailUrl")
+                        .IsRequired()
+                        .HasMaxLength(2048)
+                        .HasColumnType("character varying(2048)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AlbumId");
+
+                    b.ToTable("AlbumPhotos", "Content");
+                });
+
+            modelBuilder.Entity("Hutopy.Modules.Contents.Data.AlbumPhoto", b =>
+                {
+                    b.HasOne("Hutopy.Modules.Contents.Data.Album", "Album")
+                        .WithMany("Photos")
+                        .HasForeignKey("AlbumId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Album");
+                });
+
+            modelBuilder.Entity("Hutopy.Modules.Contents.Data.Album", b =>
+                {
+                    b.Navigation("Photos");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

backend/Modules/Contents/Models/ContentModel.cs

@@ -0,0 +1,18 @@
+namespace Hutopy.Modules.Contents.Models;
+
+[PublicAPI]
+public class ContentModel
+{
+    public required Guid Id { get; init; }
+    public required Guid CreatedBy { get; init; }
+    public required string CreatedByName { get; init; }
+    public required string? CreatedByPortraitUrl { get; init; }
+    public required DateTimeOffset CreatedAt { get; init; }
+    public Guid? DeletedBy { get; init; } 
+    public DateTimeOffset? DeletedAt { get; init; }
+    public required string Title { get; init; }
+    public required string Description { get; init; }
+    public string HtmlFileUrl { get; init; } = "";
+    public required string[]? Urls { get; init; }
+    public string? ThumbnailUrl { get; init; }
+}

backend/Modules/Contents/Models/FollowModel.cs

@@ -0,0 +1,7 @@
+namespace Hutopy.Modules.Contents.Models;
+
+[PublicAPI]
+public record FollowModel(
+    Guid CreatorId,
+    string CreatorName,
+    string? CreatorPortraitUrl);

backend/Modules/Creators/Configuration/CreatorOptions.cs

@@ -0,0 +1,8 @@
+namespace Hutopy.Modules.Creators.Configuration;
+
+public class CreatorOptions
+{
+    public const string ConfigurationSection = "Creators";
+    
+    public TimeSpan SlugReservationDuration { get; set; }
+}

backend/Modules/Creators/Contracts/CreatorReference.cs

@@ -0,0 +1,9 @@
+namespace Hutopy.Modules.Creators.Contracts;
+
+public record CreatorReference(
+    Guid Id,
+    string Name,
+    string? PortraitUrl,
+    bool OnboardingComplete,
+    bool AcceptCharges,
+    string? StripeAccountId);

backend/Modules/Creators/Contracts/ICreatorLookup.cs

@@ -0,0 +1,6 @@
+namespace Hutopy.Modules.Creators.Contracts;
+
+public interface ICreatorLookup
+{
+    Task<CreatorReference?> GetCreatorAsync(Guid creatorId, CancellationToken cancellationToken = default);
+}

backend/Modules/Creators/Data/Creator.cs

@@ -0,0 +1,32 @@
+using System.ComponentModel.DataAnnotations;
+
+namespace Hutopy.Modules.Creators.Data;
+
+public class Creator
+{
+    public Guid Id { get; set; }
+    
+    public Guid CreatedBy { get; set; } 
+    public DateTimeOffset CreatedAt { get; init; }   
+    public Guid? DeletedBy { get; set; }
+    public DateTimeOffset? DeletedAt { get; set; }
+    
+    /// <summary>
+    /// Soft‑delete flag (false by default, true once DeletedAt is set)
+    /// </summary>
+    public bool IsDeleted { get; private set; }   // private set → EF updates it
+
+    [MaxLength(2048)] public string? BannerUrl { get; set; }
+    [MaxLength(2048)] public string? PortraitUrl { get; set; }
+    public bool Verified { get; set; }
+    [MaxLength(256)] public required string Name { get; set; }
+    [MaxLength(128)] public required string Slug { get; set; }
+    [MaxLength(256)] public string? Title { get; set; }
+
+    [MaxLength(21)] public string? StripeAccountId { get; set; }
+    public bool IsStripeDetailsSubmitted { get; set; }
+    public bool IsStripePayoutReady { get; set; }
+    public bool IsStripeChargesEnabled { get; set; }
+    public Socials Socials { get; set; } = new();
+    public Presentation Presentation { get; set; } = new() { Description = "Welcome to my profile!" };
+}

backend/Modules/Creators/Data/CreatorsDbContext.cs

@@ -0,0 +1,46 @@
+namespace Hutopy.Modules.Creators.Data;
+
+public class CreatorsDbContext(
+    DbContextOptions<CreatorsDbContext> options)
+    : DbContext(options)
+{
+    public const string SchemaName = "Creators";
+
+    public DbSet<Creator> Creators => Set<Creator>();
+    public DbSet<Slugs> Slugs => Set<Slugs>();
+
+    protected override void OnModelCreating(
+        ModelBuilder modelBuilder)
+    {
+        modelBuilder.HasDefaultSchema(SchemaName);
+
+        modelBuilder
+            .Entity<Slugs>()
+            .Property(x => x.NormalizedName)
+            .HasComputedColumnSql("LOWER(\"Name\")", stored: true);
+
+        modelBuilder
+            .Entity<Slugs>()
+            .HasIndex(x => x.NormalizedName)
+            .IsUnique();
+
+        modelBuilder
+            .Entity<Creator>()
+            .Property(c => c.IsDeleted)
+            .HasComputedColumnSql("\"DeletedAt\" IS NOT NULL", stored: true); // bool
+
+        modelBuilder
+            .Entity<Creator>()
+            .OwnsOne<Socials>(x => x.Socials)
+            .ToTable(nameof(Socials));
+
+        modelBuilder
+            .Entity<Creator>()
+            .OwnsOne<Presentation>(x => x.Presentation)
+            .ToTable(nameof(Presentation));
+        
+        modelBuilder
+            .Entity<Creator>()
+            .HasQueryFilter(c => !c.IsDeleted);
+    }
+}

backend/Modules/Creators/Data/Presentation.cs

@@ -0,0 +1,11 @@
+using System.ComponentModel.DataAnnotations;
+
+namespace Hutopy.Modules.Creators.Data;
+
+public class Presentation
+{
+    public string Description { get; set; } = null!;
+    [MaxLength(2048)] public string? VideoUrl { get; set; }
+    [MaxLength(256)] public string? PhoneNumber { get; set; }
+    [MaxLength(256)] public string? Email { get; set; }
+}

backend/Modules/Creators/Data/Slugs.cs

@@ -0,0 +1,14 @@
+using System.ComponentModel.DataAnnotations;
+
+namespace Hutopy.Modules.Creators.Data;
+
+public class Slugs
+{
+    public Guid Id { get; set; }
+    public Guid CreatedBy { get; set; }
+    public DateTimeOffset CreatedAt { get; init; }
+    public Guid? UsedBy { get; set; }
+    [MaxLength(128)] public string Name { get; set; } = null!;
+    [MaxLength(128)] public string NormalizedName { get; set; } = null!;
+    public DateTimeOffset ReservedUntil { get; set; }
+}

backend/Modules/Creators/Data/Socials.cs

@@ -0,0 +1,15 @@
+using System.ComponentModel.DataAnnotations;
+
+namespace Hutopy.Modules.Creators.Data;
+
+public class Socials
+{
+    [MaxLength(2048)] public string? FacebookUrl { get; set; }
+    [MaxLength(2048)] public string? InstagramUrl { get; set; }
+    [MaxLength(2048)] public string? XUrl { get; set; }
+    [MaxLength(2048)] public string? LinkedInUrl { get; set; }
+    [MaxLength(2048)] public string? TikTokUrl { get; set; }
+    [MaxLength(2048)] public string? YoutubeUrl { get; set; }
+    [MaxLength(2048)] public string? RedditUrl { get; set; }
+    [MaxLength(2048)] public string? WebsiteUrl { get; set; }
+}

backend/Modules/Creators/DependencyInjection.cs

@@ -0,0 +1,35 @@
+using Hutopy.Modules.Creators.Configuration;
+using Hutopy.Modules.Creators.Contracts;
+using Hutopy.Modules.Creators.Data;
+using Hutopy.Modules.Creators.Services;
+
+namespace Hutopy.Modules.Creators;
+
+public static class DependencyInjection
+{
+    public static WebApplicationBuilder AddCreatorModule(
+        this WebApplicationBuilder builder,
+        Action<DbContextOptionsBuilder>? configureAction = null)
+    {
+        builder.Services.Configure<CreatorOptions>(
+            builder.Configuration.GetSection(CreatorOptions.ConfigurationSection));
+        builder.Services.AddScoped<SlugPurger>();
+        
+        builder.Services.AddDbContext<CreatorsDbContext>(configureAction);
+        builder.Services.AddTransient<ICreatorLookup, CreatorLookup>();
+        
+        return builder;
+    }
+    
+    public static async Task<IApplicationBuilder> UseCreatorModuleAsync(
+        this IApplicationBuilder app,
+        CancellationToken cancellationToken = default)
+    {
+        var scopeFactory = app.ApplicationServices.GetRequiredService<IServiceScopeFactory>();
+        using var scope = scopeFactory.CreateScope();
+        await using var context = scope.ServiceProvider.GetRequiredService<CreatorsDbContext>();
+        await context.Database.MigrateAsync(cancellationToken: cancellationToken);
+
+        return app;
+    }
+}

backend/Modules/Creators/Features/ChangeBanner.cs

@@ -0,0 +1,60 @@
+using Hutopy.Infrastructure.BlobStorage.Contracts;
+using Hutopy.Modules.Creators.Data;
+
+namespace Hutopy.Modules.Creators.Features;
+
+[PublicAPI]
+public static class ChangeBanner
+{
+    public record Request(
+        Guid CreatorId,
+        IFormFile File);
+
+    public record Response(
+        string BlobUrl);
+
+    public class Handler(
+        CreatorsDbContext context,
+        IBlobStorage blobStorage)
+        : Endpoint<Request, Response>
+    {
+        public override void Configure()
+        {
+            Post("/api/creators/{CreatorId}/banner");
+            Options(o => o.WithTags("Creators"));
+            AllowFileUploads();
+        }
+
+        public override async Task HandleAsync(
+            Request request,
+            CancellationToken ct)
+        {
+            var creator = await context
+                .Creators
+                .SingleOrDefaultAsync(
+                    c => c.Id == request.CreatorId,
+                    cancellationToken: ct);
+
+            if (creator is null)
+            {
+                await SendNotFoundAsync(ct);
+                return;
+            }
+
+            var blobUrl = await blobStorage.UploadFileAsync(
+                ContainerNames.Creators,
+                $"{request.CreatorId}/{SubDirectoryNames.Profile}/{CommonFileNames.BannerPicture}",
+                request.File.OpenReadStream(),
+                request.File.ContentType,
+                ct);
+
+            creator.BannerUrl = $"{blobUrl}?t={DateTimeOffset.UtcNow.ToUnixTimeMilliseconds()}";
+
+            await context.SaveChangesAsync(ct);
+
+            await SendOkAsync(
+                new Response(blobUrl),
+                ct);
+        }
+    }
+}

backend/Modules/Creators/Features/ChangeEmail.cs

@@ -0,0 +1,67 @@
+using Hutopy.Infrastructure.Security;
+using Hutopy.Modules.Creators.Data;
+
+namespace Hutopy.Modules.Creators.Features;
+
+[PublicAPI]
+public record ChangeEmailRequest(
+    Guid CreatorId,
+    string? Email);
+
+[PublicAPI]
+public sealed class ChangeEmailRequestValidator : Validator<ChangeEmailRequest>
+{
+    public ChangeEmailRequestValidator()
+    {
+        RuleFor(x => x.CreatorId)
+            .NotEmpty()
+            .WithMessage("Creator ID is required");
+
+        RuleFor(x => x.Email)
+            .Must(email => email == null || !string.IsNullOrWhiteSpace(email))
+            .WithMessage("Email cannot be empty if provided");
+    }
+}
+
+[PublicAPI]
+public class ChangeEmailHandler(
+    CreatorsDbContext context)
+    : Endpoint<ChangeEmailRequest>
+{
+    public override void Configure()
+    {
+        Post("/api/creators/{CreatorId}/email");
+        Options(o => o.WithTags("Creators"));
+    }
+
+    public override async Task HandleAsync(
+        ChangeEmailRequest request,
+        CancellationToken ct)
+    {
+        var creator = await context
+            .Creators
+            .Include(c => c.Presentation)
+            .SingleOrDefaultAsync(
+                c => c.Id == request.CreatorId,
+                cancellationToken: ct);
+
+        if (creator is null)
+        {
+            await SendNotFoundAsync(ct);
+            return;
+        }
+
+        // Check if the current user is the creator
+        if (creator.CreatedBy != User.GetUserId())
+        {
+            await SendUnauthorizedAsync(ct);
+            return;
+        }
+
+        creator.Presentation.Email = request.Email?.Trim();
+        
+        await context.SaveChangesAsync(ct);
+        
+        await SendOkAsync(ct);
+    }
+} 

backend/Modules/Creators/Features/ChangeLogo.cs

@@ -0,0 +1,74 @@
+using Hutopy.Infrastructure.BlobStorage.Contracts;
+using Hutopy.Modules.Creators.Data;
+
+namespace Hutopy.Modules.Creators.Features;
+
+[PublicAPI]
+public record ChangeLogoRequest(
+    Guid CreatorId,
+    IFormFile File);
+
+[PublicAPI]
+public record ChangeLogoResponse(
+    string BlobUrl);
+
+[PublicAPI]
+public sealed class ChangeLogoRequestValidator : Validator<ChangeLogoRequest>
+{
+    public ChangeLogoRequestValidator()
+    {
+        RuleFor(x => x.CreatorId)
+            .NotNull()
+            .NotEmpty();
+
+        RuleFor(x => x.File)
+            .NotNull()
+            .NotEmpty();
+    }
+}
+
+[PublicAPI]
+public class ChangeLogoHandler(
+    CreatorsDbContext context,
+    IBlobStorage blobStorage)
+    : Endpoint<ChangeLogoRequest>
+{
+    public override void Configure()
+    {
+        Post("/api/creators/{CreatorId}/logo");
+        Options(o => o.WithTags("Creators"));
+        AllowFileUploads();
+    }
+
+    public override async Task HandleAsync(
+        ChangeLogoRequest request,
+        CancellationToken ct)
+    {
+        var creator = await context
+            .Creators
+            .SingleOrDefaultAsync(
+                c => c.Id == request.CreatorId,
+                cancellationToken: ct);
+
+        if (creator is null)
+        {
+            await SendNotFoundAsync(ct);
+            return;
+        }
+
+        var blobUrl = await blobStorage.UploadFileAsync(
+            ContainerNames.Creators,
+            $"{request.CreatorId}/{SubDirectoryNames.Profile}/{CommonFileNames.ProfilePicture}",
+            request.File.OpenReadStream(),
+            request.File.ContentType,
+            ct);
+
+        creator.PortraitUrl = $"{blobUrl}?t={DateTimeOffset.UtcNow.ToUnixTimeMilliseconds()}";
+
+        await context.SaveChangesAsync(ct);
+
+        await SendOkAsync(
+            new ChangeLogoResponse(blobUrl),
+            ct);
+    }
+}

backend/Modules/Creators/Features/ChangeName.cs

@@ -0,0 +1,49 @@
+using Hutopy.Modules.Creators.Data;
+
+namespace Hutopy.Modules.Creators.Features;
+
+[PublicAPI]
+public record ChangeNameRequest(
+    Guid CreatorId,
+    string Name);
+
+[PublicAPI]
+internal sealed class ChangeNameRequestValidator
+    : Validator<ChangeNameRequest>
+{
+    public ChangeNameRequestValidator()
+    {
+        RuleFor(r => r.Name)
+            .NotNull().WithMessage("You should specify the Name")
+            .NotEmpty().WithMessage("You should specify a valid/not empty Name");
+    }
+}
+
+[PublicAPI]
+public class ChangeNameHandler(
+    CreatorsDbContext context)
+    : Endpoint<ChangeNameRequest>
+{
+    public override void Configure()
+    {
+        Post("/api/creators/{CreatorId}/name");
+        Options(o => o.WithTags("Creators"));
+    }
+
+    public override async Task HandleAsync(
+        ChangeNameRequest request,
+        CancellationToken ct)
+    {
+        var creator = await context
+            .Creators
+            .SingleAsync(
+                c => c.Id == request.CreatorId,
+                cancellationToken: ct);
+
+        creator.Name = request.Name;
+
+        await context.SaveChangesAsync(ct);
+
+        await SendOkAsync(ct);
+    }
+}

backend/Modules/Creators/Features/ChangePhoneNumber.cs

@@ -0,0 +1,67 @@
+using Hutopy.Infrastructure.Security;
+using Hutopy.Modules.Creators.Data;
+
+namespace Hutopy.Modules.Creators.Features;
+
+[PublicAPI]
+public record ChangePhoneNumberRequest(
+    Guid CreatorId,
+    string? PhoneNumber);
+
+[PublicAPI]
+public sealed class ChangePhoneNumberRequestValidator : Validator<ChangePhoneNumberRequest>
+{
+    public ChangePhoneNumberRequestValidator()
+    {
+        RuleFor(x => x.CreatorId)
+            .NotEmpty()
+            .WithMessage("Creator ID is required");
+
+        RuleFor(x => x.PhoneNumber)
+            .Must(phone => phone == null || !string.IsNullOrWhiteSpace(phone))
+            .WithMessage("Phone number cannot be empty if provided");
+    }
+}
+
+[PublicAPI]
+public class ChangePhoneNumberHandler(
+    CreatorsDbContext context)
+    : Endpoint<ChangePhoneNumberRequest>
+{
+    public override void Configure()
+    {
+        Post("/api/creators/{CreatorId}/phone");
+        Options(o => o.WithTags("Creators"));
+    }
+
+    public override async Task HandleAsync(
+        ChangePhoneNumberRequest request,
+        CancellationToken ct)
+    {
+        var creator = await context
+            .Creators
+            .Include(c => c.Presentation)
+            .SingleOrDefaultAsync(
+                c => c.Id == request.CreatorId,
+                cancellationToken: ct);
+
+        if (creator is null)
+        {
+            await SendNotFoundAsync(ct);
+            return;
+        }
+
+        // Check if the current user is the creator
+        if (creator.CreatedBy != User.GetUserId())
+        {
+            await SendUnauthorizedAsync(ct);
+            return;
+        }
+
+        creator.Presentation.PhoneNumber = request.PhoneNumber?.Trim();
+        
+        await context.SaveChangesAsync(ct);
+        
+        await SendOkAsync(ct);
+    }
+} 

backend/Modules/Creators/Features/ChangePresentationInfos.cs

@@ -0,0 +1,71 @@
+using Hutopy.Infrastructure.YouTube;
+using Hutopy.Modules.Creators.Data;
+
+namespace Hutopy.Modules.Creators.Features;
+
+[PublicAPI]
+public record ChangePresentationInfosRequest(
+    Guid CreatorId,
+    string Description,
+    string? VideoUrl);
+
+[PublicAPI]
+public sealed class ChangePresentationInfosRequestValidator : Validator<ChangePresentationInfosRequest>
+{
+    public ChangePresentationInfosRequestValidator()
+    {
+        RuleFor(x => x.CreatorId)
+            .NotEmpty()
+            .WithMessage("Creator ID is required");
+
+        RuleFor(x => x.Description)
+            .NotEmpty()
+            .WithMessage("Description is required")
+            .MaximumLength(2000)
+            .WithMessage("Description cannot exceed 2000 characters");
+
+        RuleFor(x => x.VideoUrl)
+            .Must(url => url == null || YouTubeUrlHelper.IsValidYouTubeUrlOrId(url))
+            .WithMessage("Invalid YouTube URL or video ID format");
+    }
+}
+
+[PublicAPI]
+public class ChangePresentationInfosHandler(
+    CreatorsDbContext context)
+    : Endpoint<ChangePresentationInfosRequest>
+{
+    public override void Configure()
+    {
+        Post("/api/creators/{CreatorId}/presentation-infos");
+        Options(o => o.WithTags("Creators"));
+    }
+
+    public override async Task HandleAsync(
+        ChangePresentationInfosRequest request,
+        CancellationToken ct)
+    {
+        var creator = await context
+            .Creators
+            .Include(c => c.Presentation)
+            .SingleOrDefaultAsync(
+                c => c.Id == request.CreatorId,
+                cancellationToken: ct);
+
+        if (creator is null)
+        {
+            await SendNotFoundAsync(ct);
+            return;
+        }
+
+        // Update the presentation info with the new values
+        creator.Presentation.Description = request.Description.Trim();
+        creator.Presentation.VideoUrl = request.VideoUrl != null 
+            ? YouTubeUrlHelper.ExtractVideoId(request.VideoUrl.Trim())
+            : null;
+        
+        await context.SaveChangesAsync(ct);
+        
+        await SendOkAsync(ct);
+    }
+}

backend/Modules/Creators/Features/ChangeSlug.cs

@@ -0,0 +1,97 @@
+using Hutopy.Infrastructure.Security;
+using Hutopy.Modules.Creators.Data;
+
+namespace Hutopy.Modules.Creators.Features;
+
+[PublicAPI]
+public record ChangeSlugRequest(
+    Guid CreatorId,
+    Guid SlugReservationId);
+
+[PublicAPI]
+internal sealed class ChangeSlugRequestValidator
+    : Validator<ChangeSlugRequest>
+{
+    public ChangeSlugRequestValidator()
+    {
+        RuleFor(r => r.CreatorId)
+            .NotNull().WithMessage("You should specify the CreatorId")
+            .NotEmpty().WithMessage("You should specify a valid/not empty CreatorId");
+        
+        RuleFor(r => r.SlugReservationId)
+            .NotNull().WithMessage("You should specify the SlugReservationId")
+            .NotEmpty().WithMessage("You should specify a valid/not empty SlugReservationId");
+    }
+}
+
+[PublicAPI]
+public class ChangeSlugHandler(
+    CreatorsDbContext context)
+    : Endpoint<ChangeSlugRequest>
+{
+    public override void Configure()
+    {
+        Put("/api/creators/{CreatorId}/slug");
+        Options(o => o.WithTags("Creators"));
+    }
+
+    public override async Task HandleAsync(
+        ChangeSlugRequest request,
+        CancellationToken ct)
+    {
+        await using var transaction = await context.Database.BeginTransactionAsync(ct);
+
+        try
+        {
+            var creator = await context
+                .Creators
+                .SingleAsync(
+                    c => c.Id == request.CreatorId,
+                    cancellationToken: ct);
+
+            if (creator.CreatedBy != User.GetUserId())
+            {
+                await SendUnauthorizedAsync(ct);
+                return;
+            }
+
+            var reservation = await context
+                .Slugs
+                .FirstOrDefaultAsync(
+                    s => s.Id == request.SlugReservationId,
+                    ct);
+
+            if (reservation is null)
+            {
+                await SendNotFoundAsync(ct);
+                return;
+            }
+
+            var previousReservation = await context
+                .Slugs
+                .FirstOrDefaultAsync(
+                    s => s.UsedBy == request.CreatorId,
+                    ct);
+
+            if (previousReservation is null)
+            {
+                await SendErrorsAsync(cancellation: ct);
+                return;
+            }
+
+            context.Remove(previousReservation);
+            reservation.UsedBy = creator.Id;
+            creator.Slug = reservation.NormalizedName;
+
+            await context.SaveChangesAsync(ct);
+
+            await transaction.CommitAsync(ct);
+
+            await SendOkAsync(ct);
+        }
+        catch
+        {
+            await transaction.RollbackAsync(ct);
+        }
+    }
+}

backend/Modules/Creators/Features/ChangeSocials.cs

@@ -0,0 +1,50 @@
+using Hutopy.Modules.Creators.Data;
+
+namespace Hutopy.Modules.Creators.Features;
+
+[PublicAPI]
+public record ChangeSocialsRequest(
+    Guid CreatorId,
+    string? FacebookUrl,
+    string? InstagramUrl,
+    string? XUrl,
+    string? LinkedInUrl,
+    string? TikTokUrl,
+    string? YoutubeUrl,
+    string? RedditUrl,
+    string? WebsiteUrl);
+
+[PublicAPI]
+public class ChangeSocialsHandler(
+    CreatorsDbContext context)
+    : Endpoint<ChangeSocialsRequest>
+{
+    public override void Configure()
+    {
+        Post("/api/creators/{CreatorId}/socials");
+        Options(o => o.WithTags("Creators"));
+    }
+
+    public override async Task HandleAsync(ChangeSocialsRequest request, CancellationToken ct)
+    {
+        var creator = await context
+            .Creators
+            .Include(c => c.Socials)
+            .SingleAsync(
+                c => c.Id == request.CreatorId,
+                cancellationToken: ct);
+
+        creator.Socials.FacebookUrl = request.FacebookUrl;
+        creator.Socials.InstagramUrl = request.InstagramUrl;
+        creator.Socials.XUrl = request.XUrl;
+        creator.Socials.LinkedInUrl = request.LinkedInUrl;
+        creator.Socials.TikTokUrl = request.TikTokUrl;
+        creator.Socials.YoutubeUrl = request.YoutubeUrl;
+        creator.Socials.RedditUrl = request.RedditUrl;
+        creator.Socials.WebsiteUrl = request.WebsiteUrl;
+
+        await context.SaveChangesAsync(ct);
+
+        await SendOkAsync(ct);
+    }
+}

backend/Modules/Creators/Features/ChangeTitle.cs

@@ -0,0 +1,37 @@
+using Hutopy.Modules.Creators.Data;
+
+namespace Hutopy.Modules.Creators.Features;
+
+[PublicAPI]
+public record ChangeTitleRequest(
+    Guid CreatorId,
+    string? Title);
+
+[PublicAPI]
+public class ChangeTitleHandler(
+    CreatorsDbContext context)
+    : Endpoint<ChangeTitleRequest>
+{
+    public override void Configure()
+    {
+        Post("/api/creators/{CreatorId}/title");
+        Options(o => o.WithTags("Creators"));
+    }
+
+    public override async Task HandleAsync(
+        ChangeTitleRequest request, 
+        CancellationToken ct)
+    {
+        var creator = await context
+            .Creators
+            .SingleAsync(
+                c => c.Id == request.CreatorId,
+                cancellationToken: ct);
+
+        creator.Title = request.Title;
+
+        await context.SaveChangesAsync(ct);
+
+        await SendOkAsync(ct);
+    }
+}

backend/Modules/Creators/Features/CheckStatusStripe.cs

@@ -0,0 +1,68 @@
+using Hutopy.Infrastructure.Payments.Stripe.Configuration;
+using Hutopy.Infrastructure.Security;
+using Hutopy.Modules.Creators.Data;
+using Microsoft.Extensions.Options;
+using Stripe;
+
+namespace Hutopy.Modules.Creators.Features;
+
+[PublicAPI]
+public record CheckStatusStripeResponse(
+    bool IsStripeAccountPresent,
+    bool IsStripeOnboardingComplete,
+    bool IsStripeChargesEnabled,
+    bool IsStripePayoutReady
+);
+
+public class CheckStatusStripeIdHandler(
+    IOptionsSnapshot<StripeOptions> stripeOptions,
+    CreatorsDbContext dbContext)
+    : EndpointWithoutRequest<CheckStatusStripeResponse>
+{
+    public override void Configure()
+    {
+        Post("/api/stripe/check-status");
+        Options(o => o.WithTags("Creators"));
+    }
+
+    public override async Task HandleAsync(
+        CancellationToken ct)
+    {
+        // 1. Get the creator's information
+        Guid creatorId = HttpContext.User.GetUserId();
+
+        // 2. Get or create the creator
+        Creator? creator = await dbContext.Creators.SingleOrDefaultAsync(c => c.Id == creatorId, ct);
+        if (creator is null)
+        {
+            await SendNotFoundAsync(ct);
+            return;
+        }
+
+        // 3. The Creator is not being onboarded
+        if (string.IsNullOrWhiteSpace(creator.StripeAccountId))
+        {
+            await SendErrorsAsync(cancellation: ct);
+            return;
+        }
+
+        // 4. Update Creator's stripe account information
+        StripeConfiguration.ApiKey = stripeOptions.Value.SecretKey;
+        AccountService accountService = new();
+        Account? account = await accountService.GetAsync(creator.StripeAccountId, cancellationToken: ct);
+        creator.IsStripePayoutReady = account.PayoutsEnabled;
+        creator.IsStripeChargesEnabled = account.ChargesEnabled;
+        creator.IsStripeDetailsSubmitted = account.DetailsSubmitted;
+        await dbContext.SaveChangesAsync(ct);
+
+        // 6. Return the account link URL to the client
+        await SendOkAsync(
+            new CheckStatusStripeResponse(
+                creator.StripeAccountId != null,
+                creator.IsStripeDetailsSubmitted,
+                creator.IsStripeChargesEnabled,
+                creator.IsStripePayoutReady
+            ),
+            ct);
+    }
+}

backend/Modules/Creators/Features/ConnectStripe.cs

@@ -0,0 +1,90 @@
+using Hutopy.Infrastructure.Configuration;
+using Hutopy.Infrastructure.Payments.Stripe.Configuration;
+using Hutopy.Infrastructure.Security;
+using Hutopy.Modules.Creators.Data;
+using Microsoft.Extensions.Options;
+using Stripe;
+
+namespace Hutopy.Modules.Creators.Features;
+
+[PublicAPI]
+public record ConnectStripeResponse(
+    string Url);
+
+public class ConnectStripeIdHandler(
+    IOptionsSnapshot<WebsiteOptions> websiteOptions,
+    IOptionsSnapshot<StripeOptions> stripeOptions,
+    CreatorsDbContext dbContext)
+    : EndpointWithoutRequest<ConnectStripeResponse>
+{
+    public override void Configure()
+    {
+        Post("/api/stripe/connect");
+        Options(o => o.WithTags("Creators"));
+    }
+
+    public override async Task HandleAsync(
+        CancellationToken ct)
+    {
+        // 1. Get the creator's information
+        Guid creatorId = HttpContext.User.GetUserId();
+        string email = HttpContext.User.GetEmail();
+
+        // 2. Get or create the creator
+        Creator? creator = await dbContext
+            .Creators
+            .SingleOrDefaultAsync(
+                c => c.Id == creatorId,
+                ct);
+
+        if (creator is null)
+        {
+            await SendNotFoundAsync(ct);
+            return;
+        }
+
+        // 3. Create a Stripe account
+        StripeConfiguration.ApiKey = stripeOptions.Value.SecretKey;
+        AccountService accountService = new();
+        if (string.IsNullOrWhiteSpace(creator.StripeAccountId))
+        {
+            Account? account = await accountService.CreateAsync(
+                new AccountCreateOptions
+                {
+                    Type = "express",
+                    Capabilities = new AccountCapabilitiesOptions
+                    {
+                        Transfers = new AccountCapabilitiesTransfersOptions { Requested = true }
+                    },
+                    Email = email
+                },
+                cancellationToken: ct);
+
+            // 5. Update the creator's Stripe account ID
+            creator.StripeAccountId = account.Id;
+            await dbContext.SaveChangesAsync(ct);
+        }
+
+        // 4. Check if the creator already has a Stripe account
+        if (creator is { IsStripeDetailsSubmitted: true, IsStripeChargesEnabled: true, IsStripePayoutReady: true })
+        {
+            await SendErrorsAsync(cancellation: ct);
+            return;
+        }
+
+        // 5. Create an account link 
+        AccountLinkService accountLinkService = new();
+        AccountLink? accountLink = await accountLinkService.CreateAsync(
+            new AccountLinkCreateOptions
+            {
+                Account = creator.StripeAccountId,
+                RefreshUrl = $"{websiteOptions.Value.FrontendBaseUrl}/profile?stripe=retry",
+                ReturnUrl = $"{websiteOptions.Value.FrontendBaseUrl}/profile?stripe=complete",
+                Type = "account_onboarding"
+            },
+            cancellationToken: ct);
+
+        // 6. Return the account link URL to the client
+        await SendOkAsync(new ConnectStripeResponse(accountLink.Url), ct);
+    }
+}

backend/Modules/Creators/Features/CreateCreator.cs

@@ -0,0 +1,82 @@
+using Hutopy.Infrastructure.Security;
+using Hutopy.Modules.Creators.Data;
+
+namespace Hutopy.Modules.Creators.Features;
+
+[PublicAPI]
+public record CreateCreatorRequest(
+    Guid SlugReservationId,
+    Guid CreatorId);
+
+[PublicAPI]
+public sealed class CreateCreatorRequestValidator : Validator<CreateCreatorRequest>
+{
+    public CreateCreatorRequestValidator()
+    {
+        RuleFor(r => r.SlugReservationId)
+            .NotNull()
+            .NotEmpty()
+            .WithMessage("You should specify a valid SlugReservationId");
+        
+        RuleFor(r => r.CreatorId)
+            .NotNull()
+            .NotEmpty()
+            .WithMessage("You should specify a valid CreatorId");
+    }
+}
+
+[PublicAPI]
+public sealed class CreateCreatorHandler(
+    CreatorsDbContext context)
+    : Endpoint<CreateCreatorRequest>
+{
+    public override void Configure()
+    {
+        Post("/api/creators");
+        Options(o => o.WithTags("Creators"));
+    }
+
+    public override async Task HandleAsync(
+        CreateCreatorRequest req,
+        CancellationToken ct)
+    {
+        await using var transaction = await context.Database.BeginTransactionAsync(ct);
+        
+        try
+        {
+            var slug = await context
+                .Slugs
+                .SingleAsync(s => s.Id == req.SlugReservationId, ct);
+
+            if (slug.UsedBy is not null
+                || slug.ReservedUntil < DateTimeOffset.UtcNow
+                || slug.CreatedBy != User.GetUserId())
+            {
+                await SendErrorsAsync(500, ct);
+                return;
+            }
+            
+            slug.UsedBy = req.CreatorId;
+            
+            await context.Creators.AddAsync(
+                new Creator
+                {
+                    Id = req.CreatorId,
+                    CreatedBy = User.GetUserId(),
+                    Name = slug.Name,
+                    Slug = slug.NormalizedName
+                },
+                ct);
+
+            await context.SaveChangesAsync(ct);
+
+            await transaction.CommitAsync(ct);
+            
+            await SendOkAsync(ct);
+        }
+        catch (Exception)
+        {
+            await transaction.RollbackAsync(ct);
+        }
+    }
+}

backend/Modules/Creators/Features/GetCreatorById.cs

@@ -0,0 +1,48 @@
+using Hutopy.Modules.Creators.Data;
+
+namespace Hutopy.Modules.Creators.Features;
+
+[PublicAPI]
+public sealed class GetCreatorByIdRequest
+{
+    public required Guid CreatorId { get; set; }
+}
+
+[UsedImplicitly]
+public sealed class GetCreatorByIdRequestValidator
+    : Validator<GetCreatorByIdRequest>
+{
+    public GetCreatorByIdRequestValidator()
+    {
+        RuleFor(r => r.CreatorId)
+            .NotNull().WithMessage("You should specify the CreatorId")
+            .NotEmpty().WithMessage("You should specify a valid/not empty CreatorId");
+    }
+}
+
+[PublicAPI]
+public class GetCreatorByIdHandler(
+    CreatorsDbContext context)
+    : Endpoint<GetCreatorByIdRequest, Creator>
+{
+    public override void Configure()
+    {
+        Get("/api/creators/{CreatorId}");
+        Options((o => o.WithTags("Creators")));
+        AllowAnonymous();
+    }
+
+    public override async Task HandleAsync(
+        GetCreatorByIdRequest req,
+        CancellationToken ct)
+    {
+        var creator = await context
+            .Creators
+            .FindAsync(
+                [req.CreatorId],
+                cancellationToken: ct);
+
+        if (creator is null) await SendNotFoundAsync(ct);
+        else await SendAsync(creator, cancellation: ct);
+    }
+}

backend/Modules/Creators/Features/GetCreatorBySlug.cs

@@ -0,0 +1,105 @@
+using Hutopy.Infrastructure.Security;
+using Hutopy.Modules.Creators.Data;
+
+namespace Hutopy.Modules.Creators.Features;
+
+[PublicAPI]
+public sealed class GetCreatorBySlugRequest
+{
+    public required string Name { get; set; }
+}
+
+[PublicAPI]
+public record GetCreatorBySlugResponse
+{
+    public Guid Id { get; init; }
+    public Guid CreatedBy { get; init; }
+    public DateTimeOffset CreatedAt { get; init; }
+    public Guid? DeletedBy { get; init; }
+    public DateTimeOffset? DeletedAt { get; init; }
+    public bool IsDeleted { get; init; }
+    public bool Verified { get; init; }
+    public bool AcceptDonation { get; init; }
+    public string? BannerUrl { get; init; }
+    public string? PortraitUrl { get; init; }
+    public required string Slug { get; init; }
+    public required string Name { get; init; }
+    public string? Title { get; init; }
+    public Socials? Socials { get; init; }
+    public Presentation? Presentation { get; init; }
+}
+
+[UsedImplicitly]
+public sealed class GetCreatorBySlugRequestValidator
+    : Validator<GetCreatorBySlugRequest>
+{
+    public GetCreatorBySlugRequestValidator()
+    {
+        RuleFor(r => r.Name)
+            .NotNull().WithMessage("You should specify the Name")
+            .NotEmpty().WithMessage("You should specify a valid/not empty Name");
+    }
+}
+
+[PublicAPI]
+public class GetCreatorBySlugHandler(
+    CreatorsDbContext context)
+    : Endpoint<GetCreatorBySlugRequest, GetCreatorBySlugResponse>
+{
+    public override void Configure()
+    {
+        Get("/api/creators/@{Name}");
+        Options((o => o.WithTags("Creators")));
+        AllowAnonymous();
+    }
+
+    public override async Task HandleAsync(
+        GetCreatorBySlugRequest req,
+        CancellationToken ct)
+    {
+        var creatorName = req.Name.ToLower();
+
+        var response = await context
+            .Creators
+            .IgnoreQueryFilters()
+            .Where(c => EF.Functions.ILike(c.Slug, creatorName))
+            .AsNoTracking()
+            .Select(c => new GetCreatorBySlugResponse
+            {
+                Id = c.Id,
+                CreatedBy = c.CreatedBy,
+                CreatedAt = c.CreatedAt,
+                DeletedBy = c.DeletedBy,
+                DeletedAt = c.DeletedAt,
+                IsDeleted = c.IsDeleted,
+                Verified = c.Verified,
+                BannerUrl = c.BannerUrl,
+                PortraitUrl = c.PortraitUrl,
+                Slug = c.Slug,
+                Name = c.Name,
+                Title = c.Title,
+                AcceptDonation = c.IsStripeChargesEnabled && c.IsStripePayoutReady,
+                Socials = c.Socials,
+                Presentation = c.Presentation
+            })
+            .SingleOrDefaultAsync(ct);
+
+        if (response is null)
+        {
+            await SendNotFoundAsync(ct);
+            return;
+        }
+
+        bool isOwner = User.Identity?.IsAuthenticated == true
+                       && User.GetUserId() == response.CreatedBy;
+
+        if (response.IsDeleted && !isOwner)
+        {
+            await SendNotFoundAsync(ct);
+        }
+        else
+        {
+            await SendAsync(response, cancellation: ct);
+        }
+    }
+}

backend/Modules/Creators/Features/GetCreatorProfile.cs

@@ -0,0 +1,76 @@
+using Hutopy.Infrastructure.Security;
+using Hutopy.Modules.Creators.Data;
+
+namespace Hutopy.Modules.Creators.Features;
+
+[PublicAPI]
+public sealed class GetCreatorProfileResponse
+{
+    public Guid Id { get; set; }
+    public Guid CreatedBy { get; set; }
+    public DateTimeOffset CreatedAt { get; set; }
+    public Guid? DeletedBy { get; set; }
+    public DateTimeOffset? DeletedAt { get; set; }
+    public bool IsDeleted { get; set; }
+    public required string Name { get; set; }
+    public required string Slug { get; set; }
+    public string? Title { get; set; }
+    public bool Verified { get; set; }
+    public bool IsStripeAccountPresent { get; set; }
+    public bool IsStripeDetailsSubmitted { get; set; }
+    public bool IsStripePayoutReady { get; set; }
+    public bool IsStripeChargesEnabled { get; set; }
+    public required Presentation Presentation { get; set; }
+    public required Socials Socials { get; set; }
+}
+
+[PublicAPI]
+public class GetCreatorProfileHandler(
+    CreatorsDbContext context)
+    : EndpointWithoutRequest<GetCreatorProfileResponse>
+{
+    public override void Configure()
+    {
+        Get("/api/creators/profile");
+        Options(o => o.WithTags("Creators"));
+    }
+
+    public override async Task HandleAsync(
+        CancellationToken ct)
+    {
+        GetCreatorProfileResponse? creator = await context
+            .Creators
+            .IgnoreQueryFilters()
+            .Where(c => c.Id == HttpContext.User.GetUserId())
+            .AsNoTracking()
+            .Select(c => new GetCreatorProfileResponse
+            {
+                Id = c.Id,
+                CreatedBy = c.CreatedBy,
+                CreatedAt = c.CreatedAt,
+                DeletedBy = c.DeletedBy,
+                DeletedAt = c.DeletedAt,
+                IsDeleted = c.IsDeleted,
+                Name = c.Name,
+                Slug = c.Slug,
+                Title = c.Title,
+                Verified = c.Verified,
+                IsStripeAccountPresent = !string.IsNullOrWhiteSpace(c.StripeAccountId),
+                IsStripeDetailsSubmitted = c.IsStripeDetailsSubmitted,
+                IsStripeChargesEnabled = c.IsStripeChargesEnabled,
+                IsStripePayoutReady = c.IsStripePayoutReady,
+                Presentation = c.Presentation,
+                Socials = c.Socials
+            })
+            .SingleOrDefaultAsync(ct);
+
+        if (creator is null)
+        {
+            await SendNotFoundAsync(ct);
+        }
+        else
+        {
+            await SendAsync(creator, cancellation: ct);
+        }
+    }
+}

backend/Modules/Creators/Features/RemoveCreator.cs

@@ -0,0 +1,63 @@
+using Hutopy.Infrastructure.Security;
+using Hutopy.Modules.Creators.Data;
+
+namespace Hutopy.Modules.Creators.Features;
+
+[PublicAPI]
+public record RemoveCreatorRequest(
+    string CreatorSlug);
+
+[UsedImplicitly]
+public sealed class RemoveCreatorRequestValidator : Validator<RemoveCreatorRequest>
+{
+    public RemoveCreatorRequestValidator()
+    {
+        RuleFor(r => r.CreatorSlug)
+            .NotNull()
+            .NotEmpty()
+            .WithMessage("You should specify a valid CreatorSlug");
+    }
+}
+
+[PublicAPI]
+public sealed class RemoveCreatorHandler(
+    CreatorsDbContext context)
+    : Endpoint<RemoveCreatorRequest>
+{
+    public override void Configure()
+    {
+        Delete("/api/creators/@{CreatorSlug}");
+        Options(o => o.WithTags("Creators"));
+    }
+
+    public override async Task HandleAsync(
+        RemoveCreatorRequest req,
+        CancellationToken ct)
+    {
+        var creatorSlug = req.CreatorSlug.ToLower();
+
+        var creator = await context
+            .Creators
+            .Where(c => EF.Functions.ILike(c.Slug, creatorSlug))
+            .SingleOrDefaultAsync(cancellationToken: ct);
+
+        if (creator is null)
+        {
+            await SendNotFoundAsync(ct);
+            return;
+        }
+
+        if (creator.CreatedBy != User.GetUserId())
+        {
+            await SendUnauthorizedAsync(ct);
+            return;
+        }
+
+        creator.DeletedAt = DateTimeOffset.UtcNow;
+        creator.DeletedBy = User.GetUserId();
+
+        await context.SaveChangesAsync(ct);
+
+        await SendOkAsync(ct);
+    }
+}

backend/Modules/Creators/Features/ReserveSlug.cs

@@ -0,0 +1,110 @@
+using System.Net;
+using FluentValidation.Results;
+using Hutopy.Infrastructure.Security;
+using Hutopy.Modules.Creators.Configuration;
+using Hutopy.Modules.Creators.Data;
+using Hutopy.Modules.Creators.Services;
+using Microsoft.Extensions.Options;
+using Npgsql;
+
+namespace Hutopy.Modules.Creators.Features;
+
+[PublicAPI]
+public record ReserveSlugRequest
+{
+    public required Guid ReservationId { get; set; }
+    public string Slug { get; set; } = null!;
+}
+
+[PublicAPI]
+public sealed class ReserveSlugRequestValidator : Validator<ReserveSlugRequest>
+{
+    public ReserveSlugRequestValidator()
+    {
+        RuleFor(r => r.Slug)
+            .NotEmpty()
+            .NotNull()
+            .WithMessage("You should specify a valid Slug");
+    }
+}
+
+[PublicAPI]
+public sealed class ReserveSlug(
+    CreatorsDbContext context,
+    IOptions<CreatorOptions> opts,
+    SlugPurger slugPurger)
+    : Endpoint<ReserveSlugRequest>
+{
+    public override void Configure()
+    {
+        Post("/api/creators/@{Slug}/reserve");
+        Options(o => o.WithTags("Creators"));
+    }
+
+    public override async Task HandleAsync(
+        ReserveSlugRequest req,
+        CancellationToken ct)
+    {
+        await using var transaction = await context.Database.BeginTransactionAsync(ct);
+
+        try
+        {
+            // First, purge any expired slugs
+            await slugPurger.PurgeExpiredSlugsAsync(ct);
+
+            var reservation = await context.Slugs.FirstOrDefaultAsync(
+                s => s.Id == req.ReservationId && s.CreatedBy == User.GetUserId(), 
+                cancellationToken: ct);
+
+            if (reservation == null)
+            {
+                reservation = new Slugs
+                {
+                    Id = req.ReservationId,
+                    CreatedBy = User.GetUserId(),
+                    CreatedAt = DateTimeOffset.UtcNow,
+                };
+                
+                context.Slugs.Attach(reservation);
+                context.Entry(reservation).State = EntityState.Added;
+            }
+
+            reservation.Name = req.Slug;
+            reservation.ReservedUntil = DateTimeOffset.UtcNow + opts.Value.SlugReservationDuration;
+            
+            await context.SaveChangesAsync(ct);
+
+            await transaction.CommitAsync(ct);
+
+            await SendOkAsync(new { Message = "Slug reserved." }, ct);
+        }
+        catch (Exception e)
+        {
+            await transaction.RollbackAsync(ct);
+ 
+            Logger.LogError("Transaction failed: {Message}", e.Message);
+
+            if (e.InnerException is PostgresException innerException)
+            {
+                if (innerException.ConstraintName == "IX_Slugs_NormalizedName")
+                {
+                    await SendResultAsync(new ProblemDetails(
+                        [
+                            new ValidationFailure(nameof(Slugs.Name),
+                                "The name is already taken.")
+                        ],
+                        (int)HttpStatusCode.Conflict));
+                }
+            }
+            else
+            {
+                await SendResultAsync(new ProblemDetails(
+                    [
+                        new ValidationFailure(nameof(Slugs.Name),
+                            e.Message)
+                    ],
+                    (int)HttpStatusCode.Conflict));
+            }
+        }
+    }
+}

backend/Modules/Creators/Features/RestoreCreator.cs

@@ -0,0 +1,64 @@
+using Hutopy.Infrastructure.Security;
+using Hutopy.Modules.Creators.Data;
+
+namespace Hutopy.Modules.Creators.Features;
+
+[PublicAPI]
+public record RestoreCreatorRequest(
+    string CreatorSlug);
+
+[UsedImplicitly]
+public sealed class RestoreCreatorRequestValidator : Validator<RestoreCreatorRequest>
+{
+    public RestoreCreatorRequestValidator()
+    {
+        RuleFor(r => r.CreatorSlug)
+            .NotNull()
+            .NotEmpty()
+            .WithMessage("You should specify a valid CreatorSlug");
+    }
+}
+
+[PublicAPI]
+public sealed class RestoreCreatorHandler(
+    CreatorsDbContext context)
+    : Endpoint<RestoreCreatorRequest>
+{
+    public override void Configure()
+    {
+        Put("/api/creators/@{CreatorSlug}/restore");
+        Options(o => o.WithTags("Creators"));
+    }
+
+    public override async Task HandleAsync(
+        RestoreCreatorRequest req,
+        CancellationToken ct)
+    {
+        var creatorSlug = req.CreatorSlug.ToLower();
+
+        var creator = await context
+            .Creators
+            .IgnoreQueryFilters()
+            .Where(c => EF.Functions.ILike(c.Slug, creatorSlug))
+            .SingleOrDefaultAsync(cancellationToken: ct);
+
+        if (creator is null)
+        {
+            await SendNotFoundAsync(ct);
+            return;
+        }
+
+        if (creator.CreatedBy != User.GetUserId())
+        {
+            await SendUnauthorizedAsync(ct);
+            return;
+        }
+
+        creator.DeletedAt = null;
+        creator.DeletedBy = null;
+
+        await context.SaveChangesAsync(ct);
+
+        await SendOkAsync(ct);
+    }
+}

backend/Modules/Creators/Features/RevokeStripe.cs

@@ -0,0 +1,48 @@
+using Hutopy.Infrastructure.Security;
+using Hutopy.Modules.Creators.Data;
+
+namespace Hutopy.Modules.Creators.Features;
+
+[PublicAPI]
+public class RemoveStripeHandler(
+    CreatorsDbContext dbContext)
+    : EndpointWithoutRequest
+{
+    public override void Configure()
+    {
+        Delete("/api/stripe");
+        Options(o => o.WithTags("Creators"));
+    }
+
+    public override async Task HandleAsync(CancellationToken ct)
+    {
+        // 1. Get the creator's ID from the authenticated user
+        Guid creatorId = HttpContext.User.GetUserId();
+
+        // 2. Retrieve the creator from the database
+        Creator? creator = await dbContext
+            .Creators
+            .SingleOrDefaultAsync(
+                c => c.Id == creatorId,
+                ct);
+
+        // 3. If the creator doesn't exist or has no Stripe account linked, return 404
+        if (creator is null || string.IsNullOrWhiteSpace(creator.StripeAccountId))
+        {
+            await SendNotFoundAsync(ct);
+            return;
+        }
+
+        // 4. Remove Stripe configuration
+        creator.StripeAccountId = null;
+        creator.IsStripeDetailsSubmitted = false;
+        creator.IsStripeChargesEnabled = false;
+        creator.IsStripePayoutReady = false;
+
+        // 5. Persist changes
+        await dbContext.SaveChangesAsync(ct);
+
+        // 6. Respond with success
+        await SendOkAsync(ct);
+    }
+}

backend/Modules/Creators/Migrations/20250609203815_Initial.Designer.cs

@@ -0,0 +1,221 @@
+// <auto-generated />
+using System;
+using Hutopy.Modules.Creators.Data;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+
+#nullable disable
+
+namespace Hutopy.Modules.Creators.Migrations
+{
+    [DbContext(typeof(CreatorsDbContext))]
+    [Migration("20250609203815_Initial")]
+    partial class Initial
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasDefaultSchema("Creators")
+                .HasAnnotation("ProductVersion", "9.0.3")
+                .HasAnnotation("Relational:MaxIdentifierLength", 63);
+
+            NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
+
+            modelBuilder.Entity("Hutopy.Modules.Creators.Data.Creator", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<bool>("AcceptDonation")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("BannerUrl")
+                        .HasMaxLength(2048)
+                        .HasColumnType("character varying(2048)");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<Guid>("CreatedBy")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset?>("DeletedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<Guid?>("DeletedBy")
+                        .HasColumnType("uuid");
+
+                    b.Property<bool>("IsDeleted")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("boolean")
+                        .HasComputedColumnSql("\"DeletedAt\" IS NOT NULL", true);
+
+                    b.Property<bool>("IsStripeChargesEnabled")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("IsStripeOnboardingComplete")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("IsStripePayoutReady")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("PortraitUrl")
+                        .HasMaxLength(2048)
+                        .HasColumnType("character varying(2048)");
+
+                    b.Property<string>("Slug")
+                        .IsRequired()
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.Property<string>("StripeAccountId")
+                        .HasMaxLength(21)
+                        .HasColumnType("character varying(21)");
+
+                    b.Property<string>("Title")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<bool>("Verified")
+                        .HasColumnType("boolean");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Creators", "Creators");
+                });
+
+            modelBuilder.Entity("Hutopy.Modules.Creators.Data.Slugs", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<Guid>("CreatedBy")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.Property<string>("NormalizedName")
+                        .IsRequired()
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)")
+                        .HasComputedColumnSql("LOWER(\"Name\")", true);
+
+                    b.Property<DateTimeOffset>("ReservedUntil")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<Guid?>("UsedBy")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("NormalizedName")
+                        .IsUnique();
+
+                    b.ToTable("Slugs", "Creators");
+                });
+
+            modelBuilder.Entity("Hutopy.Modules.Creators.Data.Creator", b =>
+                {
+                    b.OwnsOne("Hutopy.Modules.Creators.Data.Presentation", "Presentation", b1 =>
+                        {
+                            b1.Property<Guid>("CreatorId")
+                                .HasColumnType("uuid");
+
+                            b1.Property<string>("Description")
+                                .IsRequired()
+                                .HasColumnType("text");
+
+                            b1.Property<string>("Email")
+                                .HasMaxLength(256)
+                                .HasColumnType("character varying(256)");
+
+                            b1.Property<string>("PhoneNumber")
+                                .HasMaxLength(256)
+                                .HasColumnType("character varying(256)");
+
+                            b1.Property<string>("VideoUrl")
+                                .HasMaxLength(2048)
+                                .HasColumnType("character varying(2048)");
+
+                            b1.HasKey("CreatorId");
+
+                            b1.ToTable("Presentation", "Creators");
+
+                            b1.WithOwner()
+                                .HasForeignKey("CreatorId");
+                        });
+
+                    b.OwnsOne("Hutopy.Modules.Creators.Data.Socials", "Socials", b1 =>
+                        {
+                            b1.Property<Guid>("CreatorId")
+                                .HasColumnType("uuid");
+
+                            b1.Property<string>("FacebookUrl")
+                                .HasMaxLength(2048)
+                                .HasColumnType("character varying(2048)");
+
+                            b1.Property<string>("InstagramUrl")
+                                .HasMaxLength(2048)
+                                .HasColumnType("character varying(2048)");
+
+                            b1.Property<string>("LinkedInUrl")
+                                .HasMaxLength(2048)
+                                .HasColumnType("character varying(2048)");
+
+                            b1.Property<string>("RedditUrl")
+                                .HasMaxLength(2048)
+                                .HasColumnType("character varying(2048)");
+
+                            b1.Property<string>("TikTokUrl")
+                                .HasMaxLength(2048)
+                                .HasColumnType("character varying(2048)");
+
+                            b1.Property<string>("WebsiteUrl")
+                                .HasMaxLength(2048)
+                                .HasColumnType("character varying(2048)");
+
+                            b1.Property<string>("XUrl")
+                                .HasMaxLength(2048)
+                                .HasColumnType("character varying(2048)");
+
+                            b1.Property<string>("YoutubeUrl")
+                                .HasMaxLength(2048)
+                                .HasColumnType("character varying(2048)");
+
+                            b1.HasKey("CreatorId");
+
+                            b1.ToTable("Socials", "Creators");
+
+                            b1.WithOwner()
+                                .HasForeignKey("CreatorId");
+                        });
+
+                    b.Navigation("Presentation")
+                        .IsRequired();
+
+                    b.Navigation("Socials")
+                        .IsRequired();
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

backend/Modules/Creators/Migrations/20250609203815_Initial.cs

@@ -0,0 +1,141 @@
+using System;
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace Hutopy.Modules.Creators.Migrations
+{
+    /// <inheritdoc />
+    public partial class Initial : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.EnsureSchema(
+                name: "Creators");
+
+            migrationBuilder.CreateTable(
+                name: "Creators",
+                schema: "Creators",
+                columns: table => new
+                {
+                    Id = table.Column<Guid>(type: "uuid", nullable: false),
+                    CreatedBy = table.Column<Guid>(type: "uuid", nullable: false),
+                    CreatedAt = table.Column<DateTimeOffset>(type: "timestamp with time zone", nullable: false),
+                    DeletedBy = table.Column<Guid>(type: "uuid", nullable: true),
+                    DeletedAt = table.Column<DateTimeOffset>(type: "timestamp with time zone", nullable: true),
+                    IsDeleted = table.Column<bool>(type: "boolean", nullable: false, computedColumnSql: "\"DeletedAt\" IS NOT NULL", stored: true),
+                    BannerUrl = table.Column<string>(type: "character varying(2048)", maxLength: 2048, nullable: true),
+                    PortraitUrl = table.Column<string>(type: "character varying(2048)", maxLength: 2048, nullable: true),
+                    Verified = table.Column<bool>(type: "boolean", nullable: false),
+                    Name = table.Column<string>(type: "character varying(256)", maxLength: 256, nullable: false),
+                    Slug = table.Column<string>(type: "character varying(128)", maxLength: 128, nullable: false),
+                    Title = table.Column<string>(type: "character varying(256)", maxLength: 256, nullable: true),
+                    StripeAccountId = table.Column<string>(type: "character varying(21)", maxLength: 21, nullable: true),
+                    IsStripeOnboardingComplete = table.Column<bool>(type: "boolean", nullable: false),
+                    IsStripePayoutReady = table.Column<bool>(type: "boolean", nullable: false),
+                    IsStripeChargesEnabled = table.Column<bool>(type: "boolean", nullable: false),
+                    AcceptDonation = table.Column<bool>(type: "boolean", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_Creators", x => x.Id);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "Slugs",
+                schema: "Creators",
+                columns: table => new
+                {
+                    Id = table.Column<Guid>(type: "uuid", nullable: false),
+                    CreatedBy = table.Column<Guid>(type: "uuid", nullable: false),
+                    CreatedAt = table.Column<DateTimeOffset>(type: "timestamp with time zone", nullable: false),
+                    UsedBy = table.Column<Guid>(type: "uuid", nullable: true),
+                    Name = table.Column<string>(type: "character varying(128)", maxLength: 128, nullable: false),
+                    NormalizedName = table.Column<string>(type: "character varying(128)", maxLength: 128, nullable: false, computedColumnSql: "LOWER(\"Name\")", stored: true),
+                    ReservedUntil = table.Column<DateTimeOffset>(type: "timestamp with time zone", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_Slugs", x => x.Id);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "Presentation",
+                schema: "Creators",
+                columns: table => new
+                {
+                    CreatorId = table.Column<Guid>(type: "uuid", nullable: false),
+                    Description = table.Column<string>(type: "text", nullable: false),
+                    VideoUrl = table.Column<string>(type: "character varying(2048)", maxLength: 2048, nullable: true),
+                    PhoneNumber = table.Column<string>(type: "character varying(256)", maxLength: 256, nullable: true),
+                    Email = table.Column<string>(type: "character varying(256)", maxLength: 256, nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_Presentation", x => x.CreatorId);
+                    table.ForeignKey(
+                        name: "FK_Presentation_Creators_CreatorId",
+                        column: x => x.CreatorId,
+                        principalSchema: "Creators",
+                        principalTable: "Creators",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "Socials",
+                schema: "Creators",
+                columns: table => new
+                {
+                    CreatorId = table.Column<Guid>(type: "uuid", nullable: false),
+                    FacebookUrl = table.Column<string>(type: "character varying(2048)", maxLength: 2048, nullable: true),
+                    InstagramUrl = table.Column<string>(type: "character varying(2048)", maxLength: 2048, nullable: true),
+                    XUrl = table.Column<string>(type: "character varying(2048)", maxLength: 2048, nullable: true),
+                    LinkedInUrl = table.Column<string>(type: "character varying(2048)", maxLength: 2048, nullable: true),
+                    TikTokUrl = table.Column<string>(type: "character varying(2048)", maxLength: 2048, nullable: true),
+                    YoutubeUrl = table.Column<string>(type: "character varying(2048)", maxLength: 2048, nullable: true),
+                    RedditUrl = table.Column<string>(type: "character varying(2048)", maxLength: 2048, nullable: true),
+                    WebsiteUrl = table.Column<string>(type: "character varying(2048)", maxLength: 2048, nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_Socials", x => x.CreatorId);
+                    table.ForeignKey(
+                        name: "FK_Socials_Creators_CreatorId",
+                        column: x => x.CreatorId,
+                        principalSchema: "Creators",
+                        principalTable: "Creators",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Slugs_NormalizedName",
+                schema: "Creators",
+                table: "Slugs",
+                column: "NormalizedName",
+                unique: true);
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropTable(
+                name: "Presentation",
+                schema: "Creators");
+
+            migrationBuilder.DropTable(
+                name: "Slugs",
+                schema: "Creators");
+
+            migrationBuilder.DropTable(
+                name: "Socials",
+                schema: "Creators");
+
+            migrationBuilder.DropTable(
+                name: "Creators",
+                schema: "Creators");
+        }
+    }
+}

backend/Modules/Creators/Migrations/20250610200446_AddStripe.Designer.cs

@@ -0,0 +1,218 @@
+// <auto-generated />
+using System;
+using Hutopy.Modules.Creators.Data;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+
+#nullable disable
+
+namespace Hutopy.Modules.Creators.Migrations
+{
+    [DbContext(typeof(CreatorsDbContext))]
+    [Migration("20250610200446_AddStripe")]
+    partial class AddStripe
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasDefaultSchema("Creators")
+                .HasAnnotation("ProductVersion", "9.0.3")
+                .HasAnnotation("Relational:MaxIdentifierLength", 63);
+
+            NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
+
+            modelBuilder.Entity("Hutopy.Modules.Creators.Data.Creator", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("BannerUrl")
+                        .HasMaxLength(2048)
+                        .HasColumnType("character varying(2048)");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<Guid>("CreatedBy")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset?>("DeletedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<Guid?>("DeletedBy")
+                        .HasColumnType("uuid");
+
+                    b.Property<bool>("IsDeleted")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("boolean")
+                        .HasComputedColumnSql("\"DeletedAt\" IS NOT NULL", true);
+
+                    b.Property<bool>("IsStripeChargesEnabled")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("IsStripeDetailsSubmitted")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("IsStripePayoutReady")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("PortraitUrl")
+                        .HasMaxLength(2048)
+                        .HasColumnType("character varying(2048)");
+
+                    b.Property<string>("Slug")
+                        .IsRequired()
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.Property<string>("StripeAccountId")
+                        .HasMaxLength(21)
+                        .HasColumnType("character varying(21)");
+
+                    b.Property<string>("Title")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<bool>("Verified")
+                        .HasColumnType("boolean");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Creators", "Creators");
+                });
+
+            modelBuilder.Entity("Hutopy.Modules.Creators.Data.Slugs", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<Guid>("CreatedBy")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.Property<string>("NormalizedName")
+                        .IsRequired()
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)")
+                        .HasComputedColumnSql("LOWER(\"Name\")", true);
+
+                    b.Property<DateTimeOffset>("ReservedUntil")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<Guid?>("UsedBy")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("NormalizedName")
+                        .IsUnique();
+
+                    b.ToTable("Slugs", "Creators");
+                });
+
+            modelBuilder.Entity("Hutopy.Modules.Creators.Data.Creator", b =>
+                {
+                    b.OwnsOne("Hutopy.Modules.Creators.Data.Presentation", "Presentation", b1 =>
+                        {
+                            b1.Property<Guid>("CreatorId")
+                                .HasColumnType("uuid");
+
+                            b1.Property<string>("Description")
+                                .IsRequired()
+                                .HasColumnType("text");
+
+                            b1.Property<string>("Email")
+                                .HasMaxLength(256)
+                                .HasColumnType("character varying(256)");
+
+                            b1.Property<string>("PhoneNumber")
+                                .HasMaxLength(256)
+                                .HasColumnType("character varying(256)");
+
+                            b1.Property<string>("VideoUrl")
+                                .HasMaxLength(2048)
+                                .HasColumnType("character varying(2048)");
+
+                            b1.HasKey("CreatorId");
+
+                            b1.ToTable("Presentation", "Creators");
+
+                            b1.WithOwner()
+                                .HasForeignKey("CreatorId");
+                        });
+
+                    b.OwnsOne("Hutopy.Modules.Creators.Data.Socials", "Socials", b1 =>
+                        {
+                            b1.Property<Guid>("CreatorId")
+                                .HasColumnType("uuid");
+
+                            b1.Property<string>("FacebookUrl")
+                                .HasMaxLength(2048)
+                                .HasColumnType("character varying(2048)");
+
+                            b1.Property<string>("InstagramUrl")
+                                .HasMaxLength(2048)
+                                .HasColumnType("character varying(2048)");
+
+                            b1.Property<string>("LinkedInUrl")
+                                .HasMaxLength(2048)
+                                .HasColumnType("character varying(2048)");
+
+                            b1.Property<string>("RedditUrl")
+                                .HasMaxLength(2048)
+                                .HasColumnType("character varying(2048)");
+
+                            b1.Property<string>("TikTokUrl")
+                                .HasMaxLength(2048)
+                                .HasColumnType("character varying(2048)");
+
+                            b1.Property<string>("WebsiteUrl")
+                                .HasMaxLength(2048)
+                                .HasColumnType("character varying(2048)");
+
+                            b1.Property<string>("XUrl")
+                                .HasMaxLength(2048)
+                                .HasColumnType("character varying(2048)");
+
+                            b1.Property<string>("YoutubeUrl")
+                                .HasMaxLength(2048)
+                                .HasColumnType("character varying(2048)");
+
+                            b1.HasKey("CreatorId");
+
+                            b1.ToTable("Socials", "Creators");
+
+                            b1.WithOwner()
+                                .HasForeignKey("CreatorId");
+                        });
+
+                    b.Navigation("Presentation")
+                        .IsRequired();
+
+                    b.Navigation("Socials")
+                        .IsRequired();
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

backend/Modules/Creators/Migrations/20250610200446_AddStripe.cs

@@ -0,0 +1,43 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace Hutopy.Modules.Creators.Migrations
+{
+    /// <inheritdoc />
+    public partial class AddStripe : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropColumn(
+                name: "AcceptDonation",
+                schema: "Creators",
+                table: "Creators");
+
+            migrationBuilder.RenameColumn(
+                name: "IsStripeOnboardingComplete",
+                schema: "Creators",
+                table: "Creators",
+                newName: "IsStripeDetailsSubmitted");
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.RenameColumn(
+                name: "IsStripeDetailsSubmitted",
+                schema: "Creators",
+                table: "Creators",
+                newName: "IsStripeOnboardingComplete");
+
+            migrationBuilder.AddColumn<bool>(
+                name: "AcceptDonation",
+                schema: "Creators",
+                table: "Creators",
+                type: "boolean",
+                nullable: false,
+                defaultValue: false);
+        }
+    }
+}

backend/Modules/Creators/Migrations/CreatorsDbContextModelSnapshot.cs

@@ -0,0 +1,215 @@
+// <auto-generated />
+using System;
+using Hutopy.Modules.Creators.Data;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+
+#nullable disable
+
+namespace Hutopy.Modules.Creators.Migrations
+{
+    [DbContext(typeof(CreatorsDbContext))]
+    partial class CreatorsDbContextModelSnapshot : ModelSnapshot
+    {
+        protected override void BuildModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasDefaultSchema("Creators")
+                .HasAnnotation("ProductVersion", "9.0.3")
+                .HasAnnotation("Relational:MaxIdentifierLength", 63);
+
+            NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
+
+            modelBuilder.Entity("Hutopy.Modules.Creators.Data.Creator", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("BannerUrl")
+                        .HasMaxLength(2048)
+                        .HasColumnType("character varying(2048)");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<Guid>("CreatedBy")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset?>("DeletedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<Guid?>("DeletedBy")
+                        .HasColumnType("uuid");
+
+                    b.Property<bool>("IsDeleted")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("boolean")
+                        .HasComputedColumnSql("\"DeletedAt\" IS NOT NULL", true);
+
+                    b.Property<bool>("IsStripeChargesEnabled")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("IsStripeDetailsSubmitted")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("IsStripePayoutReady")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("PortraitUrl")
+                        .HasMaxLength(2048)
+                        .HasColumnType("character varying(2048)");
+
+                    b.Property<string>("Slug")
+                        .IsRequired()
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.Property<string>("StripeAccountId")
+                        .HasMaxLength(21)
+                        .HasColumnType("character varying(21)");
+
+                    b.Property<string>("Title")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<bool>("Verified")
+                        .HasColumnType("boolean");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Creators", "Creators");
+                });
+
+            modelBuilder.Entity("Hutopy.Modules.Creators.Data.Slugs", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<Guid>("CreatedBy")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.Property<string>("NormalizedName")
+                        .IsRequired()
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)")
+                        .HasComputedColumnSql("LOWER(\"Name\")", true);
+
+                    b.Property<DateTimeOffset>("ReservedUntil")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<Guid?>("UsedBy")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("NormalizedName")
+                        .IsUnique();
+
+                    b.ToTable("Slugs", "Creators");
+                });
+
+            modelBuilder.Entity("Hutopy.Modules.Creators.Data.Creator", b =>
+                {
+                    b.OwnsOne("Hutopy.Modules.Creators.Data.Presentation", "Presentation", b1 =>
+                        {
+                            b1.Property<Guid>("CreatorId")
+                                .HasColumnType("uuid");
+
+                            b1.Property<string>("Description")
+                                .IsRequired()
+                                .HasColumnType("text");
+
+                            b1.Property<string>("Email")
+                                .HasMaxLength(256)
+                                .HasColumnType("character varying(256)");
+
+                            b1.Property<string>("PhoneNumber")
+                                .HasMaxLength(256)
+                                .HasColumnType("character varying(256)");
+
+                            b1.Property<string>("VideoUrl")
+                                .HasMaxLength(2048)
+                                .HasColumnType("character varying(2048)");
+
+                            b1.HasKey("CreatorId");
+
+                            b1.ToTable("Presentation", "Creators");
+
+                            b1.WithOwner()
+                                .HasForeignKey("CreatorId");
+                        });
+
+                    b.OwnsOne("Hutopy.Modules.Creators.Data.Socials", "Socials", b1 =>
+                        {
+                            b1.Property<Guid>("CreatorId")
+                                .HasColumnType("uuid");
+
+                            b1.Property<string>("FacebookUrl")
+                                .HasMaxLength(2048)
+                                .HasColumnType("character varying(2048)");
+
+                            b1.Property<string>("InstagramUrl")
+                                .HasMaxLength(2048)
+                                .HasColumnType("character varying(2048)");
+
+                            b1.Property<string>("LinkedInUrl")
+                                .HasMaxLength(2048)
+                                .HasColumnType("character varying(2048)");
+
+                            b1.Property<string>("RedditUrl")
+                                .HasMaxLength(2048)
+                                .HasColumnType("character varying(2048)");
+
+                            b1.Property<string>("TikTokUrl")
+                                .HasMaxLength(2048)
+                                .HasColumnType("character varying(2048)");
+
+                            b1.Property<string>("WebsiteUrl")
+                                .HasMaxLength(2048)
+                                .HasColumnType("character varying(2048)");
+
+                            b1.Property<string>("XUrl")
+                                .HasMaxLength(2048)
+                                .HasColumnType("character varying(2048)");
+
+                            b1.Property<string>("YoutubeUrl")
+                                .HasMaxLength(2048)
+                                .HasColumnType("character varying(2048)");
+
+                            b1.HasKey("CreatorId");
+
+                            b1.ToTable("Socials", "Creators");
+
+                            b1.WithOwner()
+                                .HasForeignKey("CreatorId");
+                        });
+
+                    b.Navigation("Presentation")
+                        .IsRequired();
+
+                    b.Navigation("Socials")
+                        .IsRequired();
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

backend/Modules/Creators/Services/CreatorLookup.cs

@@ -0,0 +1,26 @@
+using Hutopy.Modules.Creators.Contracts;
+using Hutopy.Modules.Creators.Data;
+
+namespace Hutopy.Modules.Creators.Services;
+
+public sealed class CreatorLookup(
+    CreatorsDbContext context)
+    : ICreatorLookup
+{
+    public async Task<CreatorReference?> GetCreatorAsync(Guid creatorId, CancellationToken cancellationToken)
+    {
+        Creator? creator = await context
+            .Creators
+            .FirstOrDefaultAsync(c => c.Id == creatorId, cancellationToken);
+
+        return creator is null
+            ? null
+            : new CreatorReference(
+                creator.Id,
+                creator.Name,
+                creator.PortraitUrl,
+                creator.IsStripeDetailsSubmitted,
+                creator.IsStripeChargesEnabled,
+                creator.StripeAccountId);
+    }
+}

backend/Modules/Creators/Services/SlugPurger.cs

@@ -0,0 +1,43 @@
+using Hutopy.Modules.Creators.Data;
+
+namespace Hutopy.Modules.Creators.Services;
+
+public class SlugPurger(CreatorsDbContext context)
+{
+    private static readonly SemaphoreSlim Semaphore = new(1, 1);
+    private static DateTimeOffset s_lastPurgeTime = DateTimeOffset.MinValue;
+    private static readonly TimeSpan MinTimeBetweenPurges = TimeSpan.FromSeconds(10);
+
+    public async Task PurgeExpiredSlugsAsync(CancellationToken ct)
+    {
+        // Try to acquire the semaphore
+        if (!await Semaphore.WaitAsync(0, ct))
+        {
+            // Another purge operation is in progress, skip this one
+            return;
+        }
+
+        try
+        {
+            var now = DateTimeOffset.UtcNow;
+            if (now - s_lastPurgeTime < MinTimeBetweenPurges)
+            {
+                // Not enough time has passed since the last purge
+                return;
+            }
+
+            // Delete expired slugs that are not in use
+            await context
+                .Slugs
+                .Where(s => s.ReservedUntil < now && s.UsedBy == null)
+                .ExecuteDeleteAsync(ct);
+
+            // Update the last purge time regardless of whether we found expired slugs or not
+            s_lastPurgeTime = now;
+        }
+        finally
+        {
+            Semaphore.Release();
+        }
+    }
+} 

backend/Modules/Identity/Configuration/JwtOptions.cs

@@ -0,0 +1,14 @@
+namespace Hutopy.Modules.Identity.Configuration;
+
+public record JwtOptions
+{
+    public const string SectionName = "Authentication:Jwt";
+    
+    public required TimeSpan Lifetime { get; init; }
+    public required string Issuer { get; init; }
+    public required string Audience { get; init; }
+    public required string Key { get; init; }
+    
+    public TimeSpan RefreshTokenLifetime { get; init; }
+    public bool RefreshTokenRequireRotation { get; init; }
+}

backend/Modules/Identity/Contracts/IUserLookup.cs

@@ -0,0 +1,6 @@
+namespace Hutopy.Modules.Identity.Contracts;
+
+public interface IUserLookup
+{
+    Task<UserReference?> GetUserAsync(Guid userId, CancellationToken cancellationToken = default);
+}

backend/Modules/Identity/Contracts/KnownRoles.cs

@@ -0,0 +1,7 @@
+namespace Hutopy.Modules.Identity.Contracts;
+
+public static class KnownRoles
+{
+    public const string Administrator = nameof(Administrator);
+    public const string Creator = nameof(Creator);
+}

backend/Modules/Identity/Contracts/UserReference.cs

@@ -0,0 +1,6 @@
+namespace Hutopy.Modules.Identity.Contracts;
+
+public record UserReference(
+    Guid Id,
+    string Fullname,
+    string? PortraitUrl);

backend/Modules/Identity/Data/IdentityDbContext.cs

@@ -0,0 +1,20 @@
+using Microsoft.AspNetCore.Identity.EntityFrameworkCore;
+
+namespace Hutopy.Modules.Identity.Data
+{
+    public class IdentityDbContext(
+        DbContextOptions<IdentityDbContext> options)
+        : IdentityDbContext<User, Role, Guid>(options)
+    {
+        public const string SchemaName = "Identity";
+        
+        protected override void OnModelCreating(ModelBuilder 
+            modelBuilder)
+        {
+            base.OnModelCreating(modelBuilder);
+            
+            modelBuilder.HasDefaultSchema(SchemaName);
+        }
+
+    }
+}

backend/Modules/Identity/Data/IdentityService.cs

@@ -0,0 +1,60 @@
+using System.Security.Claims;
+using Hutopy.Modules.Identity.Models;
+
+namespace Hutopy.Modules.Identity.Data;
+
+public class IdentityService(
+    UserManager userManager,
+    IHttpContextAccessor contextAccessor
+)
+{
+    public async Task<UserModel?> GetCurrentUserAsync()
+    {
+        var currentUserId = contextAccessor.HttpContext?.User.FindFirst(ClaimTypes.NameIdentifier)?.Value;
+        if (string.IsNullOrEmpty(currentUserId))
+        {
+            return null;
+        }
+
+        UserModel? ret;
+        var user = await userManager.FindByIdAsync(currentUserId);
+
+        if (user == null) ret = null;
+        else
+        {
+            var userModel = new UserModel
+            {
+                Id = user.Id,
+                Username = user.UserName ?? string.Empty,
+                PhoneNumber = user.PhoneNumber ?? string.Empty,
+                Email = user.Email ?? string.Empty,
+                PortraitUrl = user.PortraitUrl,
+                Alias = user.Alias,
+                Firstname = user.Firstname,
+                Lastname = user.Lastname,
+                BirthDate = user.BirthDate,
+                Address = user.Address
+            };
+
+            ret = userModel;
+        }
+
+        return ret;
+    }
+
+    public async Task<IList<string>> GetCurrentUserRolesAsync()
+    {
+        var currentUserModel = await GetCurrentUserAsync();
+
+        if (currentUserModel is null) return [];
+        
+        var currentUser = await userManager.FindByIdAsync(currentUserModel.Id.ToString());
+
+        if (currentUser is null) return [];
+
+        var userRoles = await userManager.GetRolesAsync(currentUser);
+
+        return userRoles;
+    }
+
+}

backend/Modules/Identity/Data/Role.cs

@@ -0,0 +1,9 @@
+using Microsoft.AspNetCore.Identity;
+
+namespace Hutopy.Modules.Identity.Data;
+
+public class Role : IdentityRole<Guid>
+{
+    public Role() { }
+    public Role(string roleName) : base(roleName) { }
+}

backend/Modules/Identity/Data/User.cs

@@ -0,0 +1,20 @@
+using System.ComponentModel.DataAnnotations;
+using Microsoft.AspNetCore.Identity;
+
+namespace Hutopy.Modules.Identity.Data;
+
+public class User : IdentityUser<Guid>
+{
+    [MaxLength(256)] public string? Alias { get; set; }
+    [MaxLength(256)] public string? Firstname { get; set; }
+    [MaxLength(256)] public string? Lastname { get; set; }
+    public DateTime? BirthDate { get; set; }
+    [MaxLength(256)] public string? Address { get; set; }
+    [MaxLength(2048)] public string? PortraitUrl { get; set; }
+    [MaxLength(256)] public string? GoogleId { get; set; }
+    [MaxLength(256)] public string? FacebookId { get; set; }
+    [MaxLength(44)] public string? RefreshToken { get; set; }
+    public DateTime RefreshTokenExpiryTime { get; set; }
+    public string Fullname => $"{Lastname}, {Firstname}";
+}
+    

backend/Modules/Identity/Data/UserManager.cs

@@ -0,0 +1,27 @@
+using Microsoft.AspNetCore.Identity;
+using Microsoft.Extensions.Options;
+
+namespace Hutopy.Modules.Identity.Data;
+
+public sealed class UserManager(
+    IUserStore<User> store,
+    IOptions<IdentityOptions> optionsAccessor,
+    IPasswordHasher<User> passwordHasher,
+    IEnumerable<IUserValidator<User>> userValidators,
+    IEnumerable<IPasswordValidator<User>> passwordValidators,
+    ILookupNormalizer keyNormalizer,
+    IdentityErrorDescriber errors,
+    IServiceProvider services,
+    ILogger<UserManager<User>> logger)
+    : UserManager<User>(
+        store,
+        optionsAccessor,
+        passwordHasher,
+        userValidators,
+        passwordValidators,
+        keyNormalizer,
+        errors,
+        services,
+        logger)
+{
+}

backend/Modules/Identity/DependencyInjection.cs

@@ -0,0 +1,72 @@
+using Hutopy.Modules.Identity.Configuration;
+using Hutopy.Modules.Identity.Contracts;
+using Hutopy.Modules.Identity.Data;
+using Hutopy.Modules.Identity.Services;
+using Microsoft.AspNetCore.Identity;
+
+namespace Hutopy.Modules.Identity;
+
+public static class DependencyInjection
+{
+    public static WebApplicationBuilder AddIdentityModule(
+        this WebApplicationBuilder builder,
+        Action<DbContextOptionsBuilder>? configureAction = null)
+    {
+        builder.Services.AddDbContext<IdentityDbContext>(configureAction);
+
+        builder.Services.Configure<JwtOptions>(
+            builder.Configuration.GetRequiredSection(JwtOptions.SectionName));
+        
+        builder.Services.AddAuthentication()
+            .AddBearerToken(IdentityConstants.BearerScheme);
+
+        builder.Services.AddAuthorizationBuilder();
+
+        builder.Services
+            .AddIdentityCore<User>()
+            .AddUserManager<UserManager>()
+            .AddRoles<Role>()
+            .AddEntityFrameworkStores<IdentityDbContext>()
+            .AddApiEndpoints()
+            .AddDefaultTokenProviders();
+
+        // Singleton services
+        builder.Services.AddSingleton(TimeProvider.System);
+
+        // Scoped services
+        builder.Services.AddScoped<IdentityService>();
+        builder.Services.AddTransient<IUserLookup, UserLookup>();
+
+        return builder;
+    }
+
+    public static async Task<IApplicationBuilder> UseIdentityModuleAsync(
+        this IApplicationBuilder app,
+         CancellationToken cancellationToken = default)
+    {
+        var scopeFactory = app.ApplicationServices.GetRequiredService<IServiceScopeFactory>();
+        using var scope = scopeFactory.CreateScope();
+        await using var context = scope.ServiceProvider.GetRequiredService<IdentityDbContext>();
+        await context.Database.MigrateAsync(cancellationToken: cancellationToken);
+    
+        var roleManager = scope.ServiceProvider.GetRequiredService<RoleManager<Role>>();
+        await TrySeedAsync(roleManager);
+        
+        return app;
+    }
+    
+    private static async Task TrySeedAsync(RoleManager<Role> roleManager)
+    {
+        var administratorRole = new Role(KnownRoles.Administrator);
+        if (roleManager.Roles.All(r => r.Name != administratorRole.Name))
+        {
+            await roleManager.CreateAsync(administratorRole);
+        }
+
+        var roleCreator = new Role(KnownRoles.Creator);
+        if (roleManager.Roles.All(r => r.Name != roleCreator.Name))
+        {
+            await roleManager.CreateAsync(roleCreator);
+        }
+    }
+}

backend/Modules/Identity/Handlers/ChangeAddress.cs

@@ -0,0 +1,42 @@
+using Hutopy.Infrastructure.Security;
+using Hutopy.Modules.Identity.Data;
+
+namespace Hutopy.Modules.Identity.Handlers;
+
+[PublicAPI]
+public record ChangeAddressRequest(
+    string? Address);
+
+[PublicAPI]
+public class ChangeAddressHandler(
+    UserManager userManager)
+    : Endpoint<ChangeAddressRequest>
+{
+    public override void Configure()
+    {
+        Post("/api/users/address");
+        Options(o => o.WithTags("Users"));
+    }
+
+    public override async Task HandleAsync(
+        ChangeAddressRequest request,
+        CancellationToken ct)
+    {
+        var user = await userManager.FindByIdAsync(HttpContext.User.GetUserId().ToString());
+
+        if (user is null)
+        {
+            await SendNotFoundAsync(ct);
+            return;
+        }
+
+        user.Address = request.Address;
+
+        var result = await userManager.UpdateAsync(user);
+
+        if (result.Succeeded)
+            await SendOkAsync(ct);
+        else
+            await SendUnauthorizedAsync(ct);
+    }
+}

backend/Modules/Identity/Handlers/ChangeAlias.cs

@@ -0,0 +1,42 @@
+using Hutopy.Infrastructure.Security;
+using Hutopy.Modules.Identity.Data;
+
+namespace Hutopy.Modules.Identity.Handlers;
+
+[PublicAPI]
+public record ChangeAliasRequest(
+    string? Alias);
+
+[PublicAPI]
+public class ChangeAliasHandler(
+    UserManager userManager)
+    : Endpoint<ChangeAliasRequest>
+{
+    public override void Configure()
+    {
+        Post("/api/users/alias");
+        Options(o => o.WithTags("Users"));
+    }
+
+    public override async Task HandleAsync(
+        ChangeAliasRequest request,
+        CancellationToken ct)
+    {
+        var user = await userManager.FindByIdAsync(HttpContext.User.GetUserId().ToString());
+
+        if (user is null)
+        {
+            await SendNotFoundAsync(ct);
+            return;
+        }
+
+        user.Alias = request.Alias;
+
+        var result = await userManager.UpdateAsync(user);
+
+        if (result.Succeeded)
+            await SendOkAsync(ct);
+        else
+            await SendUnauthorizedAsync(ct);
+    }
+}

backend/Modules/Identity/Handlers/ChangeBirthDate.cs

@@ -0,0 +1,42 @@
+using Hutopy.Infrastructure.Security;
+using Hutopy.Modules.Identity.Data;
+
+namespace Hutopy.Modules.Identity.Handlers;
+
+[PublicAPI]
+public record ChangeBirthDateRequest(
+    DateTime BirthDate);
+
+[PublicAPI]
+public class ChangeBirthDateHandler(
+    UserManager userManager)
+    : Endpoint<ChangeBirthDateRequest>
+{
+    public override void Configure()
+    {
+        Post("/api/users/birthdate");
+        Options(o => o.WithTags("Users"));
+    }
+
+    public override async Task HandleAsync(
+        ChangeBirthDateRequest request,
+        CancellationToken ct)
+    {
+        var user = await userManager.FindByIdAsync(HttpContext.User.GetUserId().ToString());
+
+        if (user is null)
+        {
+            await SendNotFoundAsync(ct);
+            return;
+        }
+
+        user.BirthDate = request.BirthDate;
+
+        var result = await userManager.UpdateAsync(user);
+
+        if (result.Succeeded)
+            await SendOkAsync(ct);
+        else
+            await SendUnauthorizedAsync(ct);
+    }
+}

backend/Modules/Identity/Handlers/ChangeEmail.cs

@@ -0,0 +1,43 @@
+using Hutopy.Infrastructure.Security;
+using Hutopy.Modules.Identity.Data;
+
+namespace Hutopy.Modules.Identity.Handlers;
+
+[PublicAPI]
+public record ChangeEmailRequest(
+    string? Email);
+
+[PublicAPI]
+public class ChangeEmailHandler(
+    UserManager userManager)
+    : Endpoint<ChangeEmailRequest>
+{
+    public override void Configure()
+    {
+        Post("/api/users/email");
+        Options(o => o.WithTags("Users"));
+    }
+
+    public override async Task HandleAsync(
+        ChangeEmailRequest request,
+        CancellationToken ct)
+    {
+        var user = await userManager.FindByIdAsync(HttpContext.User.GetUserId().ToString());
+
+        if (user is null)
+        {
+            await SendNotFoundAsync(ct);
+            return;
+        }
+
+        user.Email = request.Email;
+
+        // TODO: check to see if identity resets the `email confirmed` flag - @jonathan
+        var result = await userManager.UpdateAsync(user);
+
+        if (result.Succeeded)
+            await SendOkAsync(ct);
+        else
+            await SendUnauthorizedAsync(ct);
+    }
+}

backend/Modules/Identity/Handlers/ChangeFullname.cs

@@ -0,0 +1,44 @@
+using Hutopy.Infrastructure.Security;
+using Hutopy.Modules.Identity.Data;
+
+namespace Hutopy.Modules.Identity.Handlers;
+
+[PublicAPI]
+public record ChangeFullnameRequest(
+    string? Firstname,
+    string? Lastname);
+
+[PublicAPI]
+public class ChangeFullnameHandler(
+    UserManager userManager)
+    : Endpoint<ChangeFullnameRequest>
+{
+    public override void Configure()
+    {
+        Post("/api/users/fullname");
+        Options(o => o.WithTags("Users"));
+    }
+
+    public override async Task HandleAsync(
+        ChangeFullnameRequest request,
+        CancellationToken ct)
+    {
+        var user = await userManager.FindByIdAsync(HttpContext.User.GetUserId().ToString());
+
+        if (user is null)
+        {
+            await SendNotFoundAsync(ct);
+            return;
+        }
+
+        user.Firstname = request.Firstname;
+        user.Lastname = request.Lastname;
+
+        var result = await userManager.UpdateAsync(user);
+
+        if (result.Succeeded)
+            await SendOkAsync(ct);
+        else
+            await SendUnauthorizedAsync(ct);
+    }
+}

backend/Modules/Identity/Handlers/ChangePhone.cs

@@ -0,0 +1,43 @@
+using Hutopy.Infrastructure.Security;
+using Hutopy.Modules.Identity.Data;
+
+namespace Hutopy.Modules.Identity.Handlers;
+
+[PublicAPI]
+public record ChangePhoneRequest(
+    string? PhoneNumber);
+
+[PublicAPI]
+public class ChangePhoneHandler(
+    UserManager userManager)
+    : Endpoint<ChangePhoneRequest>
+{
+    public override void Configure()
+    {
+        Post("/api/users/phone");
+        Options(o => o.WithTags("Users"));
+    }
+
+    public override async Task HandleAsync(
+        ChangePhoneRequest request,
+        CancellationToken ct)
+    {
+        var user = await userManager.FindByIdAsync(HttpContext.User.GetUserId().ToString());
+
+        if (user is null)
+        {
+            await SendNotFoundAsync(ct);
+            return;
+        }
+
+        user.PhoneNumber = request.PhoneNumber;
+        // TODO: check to see if identity resets the `phone confirmed` flag - @jonathan
+
+        var result = await userManager.UpdateAsync(user);
+
+        if (result.Succeeded)
+            await SendOkAsync(ct);
+        else
+            await SendUnauthorizedAsync(ct);
+    }
+}

backend/Modules/Identity/Handlers/ChangePortrait.cs

@@ -0,0 +1,73 @@
+using Hutopy.Infrastructure.BlobStorage.Contracts;
+using Hutopy.Infrastructure.Security;
+using Hutopy.Modules.Identity.Data;
+
+namespace Hutopy.Modules.Identity.Handlers;
+
+[PublicAPI]
+public record ChangePortraitRequest(
+    IFormFile File);
+
+[PublicAPI]
+public record ChangePortraitResponse(
+    string BlobUrl);
+
+[PublicAPI]
+public sealed class ChangePortraitRequestValidator : Validator<ChangePortraitRequest>
+{
+    public ChangePortraitRequestValidator()
+    {
+        RuleFor(x => x.File)
+            .NotNull()
+            .NotEmpty();
+    }
+}
+
+[PublicAPI]
+public class ChangePortraitHandler(
+    UserManager userManager,
+    IBlobStorage blobStorage)
+    : Endpoint<ChangePortraitRequest, ChangePortraitResponse>
+{
+    public override void Configure()
+    {
+        Post("/api/users/portrait");
+        Options(o => o.WithTags("Users"));
+        AllowFileUploads();
+    }
+
+    public override async Task HandleAsync(
+        ChangePortraitRequest request,
+        CancellationToken ct)
+    {
+        var user = await userManager.FindByIdAsync(HttpContext.User.GetUserId().ToString());
+
+        if (user is null)
+        {
+            await SendNotFoundAsync(ct);
+            return;
+        }
+
+        var blobUrl = await blobStorage.UploadFileAsync(
+            ContainerNames.Users,
+            $"{user.Id}/{SubDirectoryNames.Profile}/{CommonFileNames.ProfilePicture}",
+            request.File.OpenReadStream(),
+            request.File.ContentType,
+            ct);
+
+        user.PortraitUrl = blobUrl;
+
+        var result = await userManager.UpdateAsync(user);
+
+        if (result.Succeeded)
+        {
+            await SendOkAsync(
+                new ChangePortraitResponse(blobUrl),
+                ct);
+        }
+        else
+        {
+            await SendUnauthorizedAsync(ct);
+        }
+    }
+}

backend/Modules/Identity/Handlers/ForgotPassword.cs

@@ -0,0 +1,65 @@
+using System.Text;
+using System.Web;
+using Hutopy.Infrastructure.Configuration;
+using Hutopy.Infrastructure.Emailer.Contracts;
+using Hutopy.Modules.Identity.Data;
+using Microsoft.Extensions.Options;
+
+namespace Hutopy.Modules.Identity.Handlers;
+
+[PublicAPI]
+public record ForgotPasswordRequest(
+    string Email);
+
+[PublicAPI]
+public class ForgotPasswordHandler(
+    UserManager userManager,
+    IEmailSender emailSender,
+    IOptionsSnapshot<WebsiteOptions> options)
+    : Endpoint<ForgotPasswordRequest>
+{
+    public override void Configure()
+    {
+        AllowAnonymous();
+        Post("/api/users/forgot-password");
+        Options(o => o.WithTags("Users"));
+    }
+
+    public override async Task HandleAsync(
+        ForgotPasswordRequest request,
+        CancellationToken ct)
+    {
+        // Find user by email
+        var user = await userManager.FindByEmailAsync(request.Email);
+        
+        // Always return OK even if user not found to prevent email enumeration
+        if (user is null)
+        {
+            await SendOkAsync(ct);
+            return;
+        }
+
+        // Generate password reset token
+        var token = await userManager.GeneratePasswordResetTokenAsync(user);
+        
+        // URL encode the token as it may contain characters that are not URL safe
+        var encodedToken = HttpUtility.UrlEncode(token);
+        
+        // Build reset link
+        var resetLink = $"{options.Value.FrontendBaseUrl}/reset-password?email={HttpUtility.UrlEncode(request.Email)}&token={encodedToken}";
+        
+        // TODO: Write a better email template
+        var subject = "Reset Your Password";
+        var message = new StringBuilder()
+            .AppendLine("<h1>Reset Your Password</h1>")
+            .AppendLine("<p>Please click the link below to reset your password:</p>")
+            .AppendLine($"<p><a href=\"{resetLink}\">Reset Password</a></p>")
+            .AppendLine("<p>If you did not request a password reset, please ignore this email.</p>")
+            .ToString();
+        
+        // Send email
+        await emailSender.SendEmailAsync(request.Email, subject, message);
+        
+        await SendOkAsync(ct);
+    }
+}

backend/Modules/Identity/Handlers/GetCurrentUser.cs

@@ -0,0 +1,47 @@
+using Hutopy.Modules.Identity.Data;
+using Hutopy.Modules.Identity.Models;
+
+namespace Hutopy.Modules.Identity.Handlers;
+
+[PublicAPI]
+public class GetCurrentUserQueryHandler(
+    IdentityService identityService)
+    : EndpointWithoutRequest<UserDto>
+{
+    public override void Configure()
+    {
+        Get("/api/users/profile");
+        Options(o => o.WithTags("Memberships"));
+    }
+
+    public override async Task HandleAsync(
+        CancellationToken cancellationToken)
+    {
+        var userModel = await identityService.GetCurrentUserAsync();
+
+        if (userModel is null)
+        {
+            await SendNotFoundAsync(cancellationToken);
+            return;
+        }
+        
+        var roles = await identityService.GetCurrentUserRolesAsync();
+        
+        await SendOkAsync(
+            new UserDto
+            {
+                Id = userModel.Id,
+                Alias = userModel.Alias,
+                PortraitUrl = userModel.PortraitUrl,
+                Firstname = userModel.Firstname,
+                Lastname = userModel.Lastname,
+                Username = userModel.Username,
+                PhoneNumber = userModel.PhoneNumber,
+                Email = userModel.Email,
+                BirthDate = userModel.BirthDate,
+                Address = userModel.Address,
+                UserRoles = roles
+            },
+            cancellationToken);
+    }
+}

backend/Modules/Identity/Handlers/GetCurrentUserProfilePicture.cs

@@ -0,0 +1,37 @@
+using Hutopy.Infrastructure.BlobStorage.Contracts;
+using Hutopy.Modules.Identity.Data;
+
+namespace Hutopy.Modules.Identity.Handlers;
+
+[PublicAPI]
+public class GetCurrentUserPortraitHandler(
+    IdentityService identityService,
+    IBlobStorage blobStorage
+)
+    : EndpointWithoutRequest<Stream>
+{
+    public override void Configure()
+    {
+        Get("/api/users/portrait");
+        Options(o => o.WithTags("Users"));
+    }
+
+    public override async Task HandleAsync(
+        CancellationToken cancellationToken)
+    {
+        var identityUser = await identityService.GetCurrentUserAsync();
+
+        if (identityUser is null)
+        {
+            await SendNotFoundAsync(cancellationToken);
+            return;
+        }
+
+        var stream = await blobStorage.DownloadFileAsync(
+            ContainerNames.Users,
+            $"{identityUser.Id.ToString()}/{SubDirectoryNames.Profile}/{CommonFileNames.ProfilePicture}",
+            cancellationToken);
+
+        await SendOkAsync(stream, cancellationToken);
+    }
+}

backend/Modules/Identity/Handlers/Login.cs

@@ -0,0 +1,79 @@
+using Hutopy.Infrastructure.Security;
+using Hutopy.Modules.Identity.Configuration;
+using Hutopy.Modules.Identity.Data;
+using Microsoft.Extensions.Options;
+
+namespace Hutopy.Modules.Identity.Handlers;
+
+[PublicAPI]
+public record LoginRequest(
+    string Email,
+    string Password);
+
+[PublicAPI]
+public record LoginResponse(
+    string AccessToken,
+    string RefreshToken);
+
+[PublicAPI]
+public class LoginHandler(
+    UserManager userManager,
+    IOptionsSnapshot<JwtOptions> jwtOptions)
+    : Endpoint<LoginRequest, LoginResponse>
+{
+    public override void Configure()
+    {
+        AllowAnonymous();
+        Post("/api/users/login");
+        Options(o => o.WithTags("Users"));
+    }
+
+    public override async Task HandleAsync(
+        LoginRequest request,
+        CancellationToken ct)
+    {
+        // Find user by email
+        var user = await userManager.FindByEmailAsync(request.Email);
+        if (user is null)
+        {
+            await SendStringAsync(
+                "Invalid email or password",
+                401,
+                cancellation: ct);
+            return;
+        }
+
+        // Verify password
+        var isPasswordValid = await userManager.CheckPasswordAsync(user, request.Password);
+        if (!isPasswordValid)
+        {
+            await SendStringAsync(
+                "Invalid email or password",
+                401,
+                cancellation: ct);
+            return;
+        }
+
+        // Generate new refresh token
+        user.RefreshToken = RefreshTokenGenerator.Next();
+        user.RefreshTokenExpiryTime = DateTime.UtcNow.Add(jwtOptions.Value.RefreshTokenLifetime);
+        await userManager.UpdateAsync(user);
+
+        // Generate JWT token
+        var accessToken = JwtTokenHelper.GenerateJwtToken(
+            expiresIn: jwtOptions.Value.Lifetime,
+            issuer: jwtOptions.Value.Issuer,
+            audience: jwtOptions.Value.Audience,
+            key: jwtOptions.Value.Key,
+            userId: user.Id.ToString(),
+            email: user.Email ?? string.Empty,
+            alias: user.Alias,
+            firstname: user.Firstname ?? string.Empty,
+            lastname: user.Lastname ?? string.Empty,
+            portraitUrl: user.PortraitUrl);
+
+        await SendOkAsync(
+            new LoginResponse(accessToken, user.RefreshToken),
+            cancellation: ct);
+    }
+}

backend/Modules/Identity/Handlers/LoginWithFacebook.cs

@@ -0,0 +1,141 @@
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using Hutopy.Infrastructure.Security;
+using Hutopy.Modules.Identity.Configuration;
+using Hutopy.Modules.Identity.Data;
+using Microsoft.Extensions.Options;
+
+namespace Hutopy.Modules.Identity.Handlers;
+
+[PublicAPI]
+public class FacebookUserInfo
+{
+    [JsonPropertyName("id")] public required string Id { get; init; }
+    [JsonPropertyName("email")] public string? Email { get; init; } // Email might be null if not granted
+    [JsonPropertyName("name")] public required string Name { get; init; }
+    [JsonPropertyName("picture")] public required FacebookPictureData Picture { get; init; }
+}
+
+[PublicAPI]
+public class FacebookPictureData
+{
+    [JsonPropertyName("data")] public required FacebookPicture Picture { get; init; }
+}
+
+[PublicAPI]
+public class FacebookPicture
+{
+    [JsonPropertyName("url")] public required string Url { get; init; }
+}
+
+[PublicAPI]
+public record LoginWithFacebookRequest(
+    string Token);
+
+[PublicAPI]
+public record LoginWithFacebookResponse(
+    string AccessToken,
+    string RefreshToken);
+
+[PublicAPI]
+public class LoginWithFacebookHandler(
+    IHttpClientFactory httpClientFactory,
+    UserManager userManager,
+    IOptionsSnapshot<JwtOptions> jwtOptions)
+    : Endpoint<LoginWithFacebookRequest, LoginWithFacebookResponse>
+{
+    public override void Configure()
+    {
+        AllowAnonymous();
+        Post("/api/users/login-with-facebook");
+        Options(o => o.WithTags("Users"));
+    }
+
+    public override async Task HandleAsync(
+        LoginWithFacebookRequest request,
+        CancellationToken ct)
+    {
+        // Verify the token with Facebook
+        using var httpClient = httpClientFactory.CreateClient();
+        using var response = await httpClient.GetAsync(
+            $"https://graph.facebook.com/me?access_token={request.Token}&fields=id,name,email,picture.width(200).height(200)",
+            ct);
+        if (!response.IsSuccessStatusCode)
+        {
+            await SendStringAsync(
+                "The token is not valid",
+                400,
+                cancellation: ct);
+            return;
+        }
+
+        // Extract the user info (email, name, profile picture)
+        var content = await response.Content.ReadAsStringAsync(ct);
+        var userInfo = JsonSerializer.Deserialize<FacebookUserInfo>(content);
+        if (userInfo is null || string.IsNullOrEmpty(userInfo.Id))
+        {
+            await SendStringAsync(
+                "Failed to retrieve user information from Facebook",
+                400,
+                cancellation: ct);
+            return;
+        }
+
+        // Check if user exists or create a new one
+        var user = await userManager.FindByEmailAsync(userInfo.Email!);
+
+        if (user is null)
+        {
+            var generatedPassword = PasswordGenerator.Next();
+            var generatedUser = new User
+            {
+                UserName = userInfo.Email ?? $"fb_{userInfo.Id}",
+                Email = userInfo.Email,
+                Firstname = userInfo.Name.Split(' ').FirstOrDefault() ?? "",
+                Lastname = userInfo.Name.Split(' ').Skip(1).FirstOrDefault() ?? "",
+                Alias = userInfo.Name,
+                PortraitUrl = userInfo.Picture.Picture.Url,
+                FacebookId = userInfo.Id, // Storing Facebook ID
+            };
+
+            var result = await userManager.CreateAsync(
+                generatedUser,
+                generatedPassword);
+
+            if (!result.Succeeded)
+            {
+                await SendStringAsync(
+                    result.Errors.First().Description,
+                    400,
+                    cancellation: ct);
+                return;
+            }
+
+            user = generatedUser;
+        }
+
+        // Generate refresh token
+        var refreshToken = RefreshTokenGenerator.Next();
+
+        // Store refresh token in user's properties
+        user.RefreshToken = refreshToken;
+        user.RefreshTokenExpiryTime = DateTime.UtcNow.Add(jwtOptions.Value.RefreshTokenLifetime);
+        await userManager.UpdateAsync(user);
+
+        var accessToken = JwtTokenHelper.GenerateJwtToken(
+            expiresIn: jwtOptions.Value.Lifetime,
+            issuer: jwtOptions.Value.Issuer,
+            audience: jwtOptions.Value.Audience,
+            key: jwtOptions.Value.Key,
+            userId: user.Id.ToString(),
+            email: user.Email ?? string.Empty,
+            alias: user.Alias,
+            firstname: user.Firstname ?? string.Empty,
+            lastname: user.Lastname ?? string.Empty,
+            portraitUrl: user.PortraitUrl);
+
+        await SendOkAsync(
+            new LoginWithFacebookResponse(accessToken, refreshToken),
+            cancellation: ct);
+    }
+}

backend/Modules/Identity/Handlers/LoginWithGoogle.cs

@@ -0,0 +1,145 @@
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using Hutopy.Infrastructure.Security;
+using Hutopy.Modules.Identity.Configuration;
+using Hutopy.Modules.Identity.Data;
+using Microsoft.Extensions.Options;
+
+namespace Hutopy.Modules.Identity.Handlers;
+
+class GoogleToken
+{
+    [JsonPropertyName("access_token")] public required string AccessToken { get; init; }
+    [JsonPropertyName("token_type")] public required string TokenType { get; init; }
+    [JsonPropertyName("expires_in")] public required int ExpiresIn { get; init; }
+    [JsonPropertyName("scope")] public required string Scope { get; init; }
+    [JsonPropertyName("authuser")] public required string AuthUser { get; init; }
+    [JsonPropertyName("prompt")] public required string Prompt { get; init; }
+}
+
+public class GoogleUserInfo
+{
+    [JsonPropertyName("id")] public required string Id { get; init; }
+    [JsonPropertyName("email")] public required string Email { get; init; }
+    [JsonPropertyName("verified_email")] public required bool VerifiedEmail { get; init; }
+    [JsonPropertyName("name")] public required string Name { get; init; }
+    [JsonPropertyName("given_name")] public required string GivenName { get; init; }
+    [JsonPropertyName("family_name")] public string FamilyName { get; init; } = string.Empty;
+    [JsonPropertyName("picture")] public required string Picture { get; init; }
+}
+
+[PublicAPI]
+public record LoginWithGoogleRequest(
+    string Token);
+
+[PublicAPI]
+public record LoginWithGoogleResponse(
+    string AccessToken,
+    string RefreshToken);
+
+[PublicAPI]
+public class LoginWithGoogleHandler(
+    IHttpClientFactory httpClientFactory,
+    UserManager userManager,
+    IOptionsSnapshot<JwtOptions> jwtOptions)
+    : Endpoint<LoginWithGoogleRequest, LoginWithGoogleResponse>
+{
+    public override void Configure()
+    {
+        AllowAnonymous();
+        Post("/api/users/login-with-google");
+        Options(o => o.WithTags("Users"));
+    }
+
+    public override async Task HandleAsync(
+        LoginWithGoogleRequest request,
+        CancellationToken ct)
+    {
+        var googleToken = JsonSerializer.Deserialize<GoogleToken>(request.Token)!;
+
+        // Verify the token with Google
+        using var httpClient = httpClientFactory.CreateClient();
+        using var response = await httpClient.GetAsync(
+            $"https://www.googleapis.com/oauth2/v1/userinfo?access_token={googleToken.AccessToken}",
+            ct);
+        if (!response.IsSuccessStatusCode)
+        {
+            await SendStringAsync(
+                "The token is not valid",
+                400,
+                cancellation: ct);
+            return;
+        }
+
+        // Extract the user info (email, name, etc.).
+        var content = await response.Content.ReadAsStringAsync(ct);
+        var userInfo = JsonSerializer.Deserialize<GoogleUserInfo>(content);
+        if (userInfo is null
+            || !userInfo.VerifiedEmail
+            || string.IsNullOrEmpty(userInfo.Email))
+        {
+            await SendStringAsync(
+                "The token does not contain an email",
+                400,
+                cancellation: ct);
+            return;
+        }
+
+        // Check if user exists or create a new one
+        var user = await userManager.FindByEmailAsync(userInfo.Email);
+
+        if (user is null)
+        {
+            var generatedPassword = PasswordGenerator.Next();
+            var refreshToken = RefreshTokenGenerator.Next();
+            var generatedUser = new User
+            {
+                UserName = userInfo.Email,
+                Email = userInfo.Email,
+                Firstname = userInfo.GivenName,
+                Lastname = userInfo.FamilyName,
+                Alias = userInfo.Name,
+                PortraitUrl = userInfo.Picture,
+                GoogleId = userInfo.Id,
+                RefreshToken = refreshToken,
+                RefreshTokenExpiryTime = DateTime.UtcNow.Add(jwtOptions.Value.RefreshTokenLifetime)
+            };
+
+            var result = await userManager.CreateAsync(
+                generatedUser,
+                generatedPassword);
+
+            if (!result.Succeeded)
+            {
+                await SendStringAsync(
+                    result.Errors.First().Description,
+                    400,
+                    cancellation: ct);
+                return;
+            }
+
+            user = generatedUser;
+        }
+
+        // Generate new refresh token
+        user.RefreshToken = RefreshTokenGenerator.Next();
+        user.RefreshTokenExpiryTime = DateTime.UtcNow.Add(jwtOptions.Value.RefreshTokenLifetime);
+        await userManager.UpdateAsync(user);
+
+        var accessToken = JwtTokenHelper.GenerateJwtToken(
+            expiresIn: jwtOptions.Value.Lifetime,
+            issuer: jwtOptions.Value.Issuer,
+            audience: jwtOptions.Value.Audience,
+            key: jwtOptions.Value.Key,
+            userId: user.Id.ToString(),
+            email: user.Email ?? string.Empty,
+            alias: user.Alias,
+            firstname: user.Firstname ?? string.Empty,
+            lastname: user.Lastname ?? string.Empty,
+            portraitUrl: user.PortraitUrl);
+
+        await SendOkAsync(
+            new LoginWithGoogleResponse(accessToken, user.RefreshToken),
+            cancellation: ct);
+    }
+}

backend/Modules/Identity/Handlers/RefreshToken.cs

@@ -0,0 +1,71 @@
+using Hutopy.Infrastructure.Security;
+using Hutopy.Modules.Identity.Configuration;
+using Hutopy.Modules.Identity.Data;
+using Microsoft.Extensions.Options;
+
+namespace Hutopy.Modules.Identity.Handlers;
+
+[PublicAPI]
+public record RefreshTokenRequest(
+    string RefreshToken);
+
+[PublicAPI]
+public record RefreshTokenResponse(
+    string AccessToken,
+    string RefreshToken);
+
+[PublicAPI]
+public class RefreshTokenHandler(
+    UserManager userManager,
+    IOptionsSnapshot<JwtOptions> jwtOptions)
+    : Endpoint<RefreshTokenRequest, RefreshTokenResponse>
+{
+    public override void Configure()
+    {
+        AllowAnonymous();
+        Post("/api/users/refresh");
+        Options(o => o.WithTags("Users"));
+    }
+
+    public override async Task HandleAsync(
+        RefreshTokenRequest request,
+        CancellationToken ct)
+    {
+        // Find the user using the refresh token
+        var user = await userManager.Users
+            .FirstOrDefaultAsync(u => u.RefreshToken == request.RefreshToken, ct);
+
+        if (user == null || user.RefreshTokenExpiryTime <= DateTime.UtcNow)
+        {
+            await SendUnauthorizedAsync(ct);
+            return;
+        }
+
+        // Generate a new refresh token if rotation is required
+        if (jwtOptions.Value.RefreshTokenRequireRotation || user.RefreshToken is null)
+        {
+            user.RefreshToken = RefreshTokenGenerator.Next();
+        }
+
+        // Update refresh token expiry time
+        user.RefreshTokenExpiryTime = DateTime.UtcNow.Add(jwtOptions.Value.RefreshTokenLifetime);
+        await userManager.UpdateAsync(user);
+
+        // Generate a new access token
+        var accessToken = JwtTokenHelper.GenerateJwtToken(
+            expiresIn: jwtOptions.Value.Lifetime,
+            issuer: jwtOptions.Value.Issuer,
+            audience: jwtOptions.Value.Audience,
+            key: jwtOptions.Value.Key,
+            userId: user.Id.ToString(),
+            email: user.Email ?? string.Empty,
+            alias: user.Alias,
+            firstname: user.Firstname ?? string.Empty,
+            lastname: user.Lastname ?? string.Empty,
+            portraitUrl: user.PortraitUrl);
+
+        await SendOkAsync(
+            new RefreshTokenResponse(accessToken, user.RefreshToken),
+            cancellation: ct);
+    }
+} 

backend/Modules/Identity/Handlers/Register.cs

@@ -0,0 +1,97 @@
+using Hutopy.Infrastructure.Security;
+using Hutopy.Modules.Identity.Configuration;
+using Hutopy.Modules.Identity.Data;
+using Microsoft.Extensions.Options;
+
+namespace Hutopy.Modules.Identity.Handlers;
+
+[PublicAPI]
+public record RegisterRequest(
+    string Email,
+    string Password,
+    string Name);
+
+[PublicAPI]
+public record RegisterResponse(
+    string AccessToken,
+    string RefreshToken);
+
+[PublicAPI]
+public class RegisterHandler(
+    UserManager userManager,
+    IOptionsSnapshot<JwtOptions> jwtOptions)
+    : Endpoint<RegisterRequest, RegisterResponse>
+{
+    public override void Configure()
+    {
+        AllowAnonymous();
+        Post("/api/users/register");
+        Options(o => o.WithTags("Users"));
+    }
+
+    public override async Task HandleAsync(
+        RegisterRequest request,
+        CancellationToken ct)
+    {
+        // Check if the user already exists
+        var existingUser = await userManager.FindByEmailAsync(request.Email);
+        if (existingUser is not null)
+        {
+            await SendStringAsync(
+                "A user with this email already exists",
+                400,
+                cancellation: ct);
+            return;
+        }
+
+        // Create a refresh token
+        var refreshToken = RefreshTokenGenerator.Next();
+        
+        // Split the name into firstname and lastname (if provided)
+        var nameParts = request.Name.Split(' ', 2);
+        var firstname = nameParts[0];
+        var lastname = nameParts.Length > 1 ? nameParts[1] : string.Empty;
+
+        // Create a new user
+        var user = new User
+        {
+            UserName = request.Email,
+            Email = request.Email,
+            Firstname = firstname,
+            Lastname = lastname,
+            Alias = request.Name,
+            RefreshToken = refreshToken,
+            RefreshTokenExpiryTime = DateTime.UtcNow.Add(jwtOptions.Value.RefreshTokenLifetime)
+        };
+
+        var result = await userManager.CreateAsync(
+            user,
+            request.Password);
+
+        if (!result.Succeeded)
+        {
+            await SendStringAsync(
+                result.Errors.First().Description,
+                400,
+                cancellation: ct);
+            return;
+        }
+
+        // Generate JWT token
+        var accessToken = JwtTokenHelper.GenerateJwtToken(
+            expiresIn: jwtOptions.Value.Lifetime,
+            issuer: jwtOptions.Value.Issuer,
+            audience: jwtOptions.Value.Audience,
+            key: jwtOptions.Value.Key,
+            userId: user.Id.ToString(),
+            email: user.Email ?? string.Empty,
+            alias: user.Alias,
+            firstname: user.Firstname ?? string.Empty,
+            lastname: user.Lastname ?? string.Empty,
+            portraitUrl: user.PortraitUrl);
+
+        await SendOkAsync(
+            new RegisterResponse(accessToken, user.RefreshToken),
+            cancellation: ct);
+    }
+}

backend/Modules/Identity/Handlers/ResetPassword.cs

@@ -0,0 +1,55 @@
+using Hutopy.Modules.Identity.Data;
+
+namespace Hutopy.Modules.Identity.Handlers;
+
+[PublicAPI]
+public record ResetPasswordRequest(
+    string Email,
+    string Token,
+    string NewPassword);
+
+[PublicAPI]
+public class ResetPasswordHandler(
+    UserManager userManager)
+    : Endpoint<ResetPasswordRequest>
+{
+    public override void Configure()
+    {
+        AllowAnonymous();
+        Post("/api/users/reset-password");
+        Options(o => o.WithTags("Users"));
+    }
+
+    public override async Task HandleAsync(
+        ResetPasswordRequest request,
+        CancellationToken ct)
+    {
+        // Find user by email
+        var user = await userManager.FindByEmailAsync(request.Email);
+        if (user is null)
+        {
+            await SendStringAsync(
+                "Invalid request",
+                400,
+                cancellation: ct);
+            return;
+        }
+
+        // Reset password with token
+        var result = await userManager.ResetPasswordAsync(
+            user,
+            request.Token,
+            request.NewPassword);
+
+        if (!result.Succeeded)
+        {
+            await SendStringAsync(
+                "Invalid or expired token",
+                400,
+                cancellation: ct);
+            return;
+        }
+
+        await SendOkAsync(ct);
+    }
+}

backend/Modules/Identity/Handlers/SetPassword.cs

@@ -0,0 +1,50 @@
+using Hutopy.Infrastructure.Security;
+using Hutopy.Modules.Identity.Data;
+
+namespace Hutopy.Modules.Identity.Handlers;
+
+[PublicAPI]
+public record SetPasswordRequest(
+    string NewPassword);
+
+[PublicAPI]
+public class SetPasswordHandler(
+    UserManager userManager)
+    : Endpoint<SetPasswordRequest>
+{
+    public override void Configure()
+    {
+        Post("/api/users/set-password");
+        Options(o => o.WithTags("Users"));
+    }
+
+    public override async Task HandleAsync(
+        SetPasswordRequest request,
+        CancellationToken ct)
+    {
+        // Get current user id from claims
+        var userId = User.GetUserId().ToString();
+        
+        // Get user from database
+        var user = await userManager.FindByIdAsync(userId);
+        if (user is null)
+        {
+            await SendForbiddenAsync(ct);
+            return;
+        }
+
+        var resetToken = await userManager.GeneratePasswordResetTokenAsync(user);
+        var result = await userManager.ResetPasswordAsync(user, resetToken, request.NewPassword);
+        
+        if (!result.Succeeded)
+        {
+            await SendStringAsync(
+                result.Errors.First().Description,
+                400,
+                cancellation: ct);
+            return;
+        }
+        
+        await SendOkAsync(ct);
+    }
+}

backend/Modules/Identity/IdentityResultExtensions.cs

@@ -0,0 +1,14 @@
+using Hutopy.Modules.Identity.Models;
+using Microsoft.AspNetCore.Identity;
+
+namespace Hutopy.Modules.Identity;
+
+public static class IdentityResultExtensions
+{
+    public static Result ToApplicationResult(this IdentityResult result)
+    {
+        return result.Succeeded
+            ? Result.Success()
+            : Result.Failure(result.Errors.Select(e => e.Description));
+    }
+}

backend/Modules/Identity/Migrations/20250609203622_Initial.Designer.cs

@@ -0,0 +1,315 @@
+// <auto-generated />
+using System;
+using Hutopy.Modules.Identity.Data;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+
+#nullable disable
+
+namespace Hutopy.Modules.Identity.Migrations
+{
+    [DbContext(typeof(IdentityDbContext))]
+    [Migration("20250609203622_Initial")]
+    partial class Initial
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasDefaultSchema("Identity")
+                .HasAnnotation("ProductVersion", "9.0.3")
+                .HasAnnotation("Relational:MaxIdentifierLength", 63);
+
+            NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
+
+            modelBuilder.Entity("Hutopy.Modules.Identity.Data.Role", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Name")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("NormalizedName")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("NormalizedName")
+                        .IsUnique()
+                        .HasDatabaseName("RoleNameIndex");
+
+                    b.ToTable("AspNetRoles", "Identity");
+                });
+
+            modelBuilder.Entity("Hutopy.Modules.Identity.Data.User", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("AccessFailedCount")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Address")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("Alias")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<DateTime?>("BirthDate")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Email")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<bool>("EmailConfirmed")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("FacebookId")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("Firstname")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("GoogleId")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("Lastname")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<bool>("LockoutEnabled")
+                        .HasColumnType("boolean");
+
+                    b.Property<DateTimeOffset?>("LockoutEnd")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("NormalizedEmail")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("NormalizedUserName")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("PasswordHash")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PhoneNumber")
+                        .HasColumnType("text");
+
+                    b.Property<bool>("PhoneNumberConfirmed")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("PortraitUrl")
+                        .HasMaxLength(2048)
+                        .HasColumnType("character varying(2048)");
+
+                    b.Property<string>("RefreshToken")
+                        .HasMaxLength(44)
+                        .HasColumnType("character varying(44)");
+
+                    b.Property<DateTime>("RefreshTokenExpiryTime")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("SecurityStamp")
+                        .HasColumnType("text");
+
+                    b.Property<bool>("TwoFactorEnabled")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("UserName")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("NormalizedEmail")
+                        .HasDatabaseName("EmailIndex");
+
+                    b.HasIndex("NormalizedUserName")
+                        .IsUnique()
+                        .HasDatabaseName("UserNameIndex");
+
+                    b.ToTable("AspNetUsers", "Identity");
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim<System.Guid>", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("ClaimType")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ClaimValue")
+                        .HasColumnType("text");
+
+                    b.Property<Guid>("RoleId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("RoleId");
+
+                    b.ToTable("AspNetRoleClaims", "Identity");
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserClaim<System.Guid>", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("ClaimType")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ClaimValue")
+                        .HasColumnType("text");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("AspNetUserClaims", "Identity");
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserLogin<System.Guid>", b =>
+                {
+                    b.Property<string>("LoginProvider")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ProviderKey")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ProviderDisplayName")
+                        .HasColumnType("text");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("LoginProvider", "ProviderKey");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("AspNetUserLogins", "Identity");
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserRole<System.Guid>", b =>
+                {
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("RoleId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("UserId", "RoleId");
+
+                    b.HasIndex("RoleId");
+
+                    b.ToTable("AspNetUserRoles", "Identity");
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserToken<System.Guid>", b =>
+                {
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("LoginProvider")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Value")
+                        .HasColumnType("text");
+
+                    b.HasKey("UserId", "LoginProvider", "Name");
+
+                    b.ToTable("AspNetUserTokens", "Identity");
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim<System.Guid>", b =>
+                {
+                    b.HasOne("Hutopy.Modules.Identity.Data.Role", null)
+                        .WithMany()
+                        .HasForeignKey("RoleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserClaim<System.Guid>", b =>
+                {
+                    b.HasOne("Hutopy.Modules.Identity.Data.User", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserLogin<System.Guid>", b =>
+                {
+                    b.HasOne("Hutopy.Modules.Identity.Data.User", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserRole<System.Guid>", b =>
+                {
+                    b.HasOne("Hutopy.Modules.Identity.Data.Role", null)
+                        .WithMany()
+                        .HasForeignKey("RoleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Hutopy.Modules.Identity.Data.User", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserToken<System.Guid>", b =>
+                {
+                    b.HasOne("Hutopy.Modules.Identity.Data.User", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

backend/Modules/Identity/Migrations/20250609203622_Initial.cs

@@ -0,0 +1,263 @@
+using System;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+
+#nullable disable
+
+namespace Hutopy.Modules.Identity.Migrations
+{
+    /// <inheritdoc />
+    public partial class Initial : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.EnsureSchema(
+                name: "Identity");
+
+            migrationBuilder.CreateTable(
+                name: "AspNetRoles",
+                schema: "Identity",
+                columns: table => new
+                {
+                    Id = table.Column<Guid>(type: "uuid", nullable: false),
+                    Name = table.Column<string>(type: "character varying(256)", maxLength: 256, nullable: true),
+                    NormalizedName = table.Column<string>(type: "character varying(256)", maxLength: 256, nullable: true),
+                    ConcurrencyStamp = table.Column<string>(type: "text", nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_AspNetRoles", x => x.Id);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "AspNetUsers",
+                schema: "Identity",
+                columns: table => new
+                {
+                    Id = table.Column<Guid>(type: "uuid", nullable: false),
+                    Alias = table.Column<string>(type: "character varying(256)", maxLength: 256, nullable: true),
+                    Firstname = table.Column<string>(type: "character varying(256)", maxLength: 256, nullable: true),
+                    Lastname = table.Column<string>(type: "character varying(256)", maxLength: 256, nullable: true),
+                    BirthDate = table.Column<DateTime>(type: "timestamp with time zone", nullable: true),
+                    Address = table.Column<string>(type: "character varying(256)", maxLength: 256, nullable: true),
+                    PortraitUrl = table.Column<string>(type: "character varying(2048)", maxLength: 2048, nullable: true),
+                    GoogleId = table.Column<string>(type: "character varying(256)", maxLength: 256, nullable: true),
+                    FacebookId = table.Column<string>(type: "character varying(256)", maxLength: 256, nullable: true),
+                    RefreshToken = table.Column<string>(type: "character varying(44)", maxLength: 44, nullable: true),
+                    RefreshTokenExpiryTime = table.Column<DateTime>(type: "timestamp with time zone", nullable: false),
+                    UserName = table.Column<string>(type: "character varying(256)", maxLength: 256, nullable: true),
+                    NormalizedUserName = table.Column<string>(type: "character varying(256)", maxLength: 256, nullable: true),
+                    Email = table.Column<string>(type: "character varying(256)", maxLength: 256, nullable: true),
+                    NormalizedEmail = table.Column<string>(type: "character varying(256)", maxLength: 256, nullable: true),
+                    EmailConfirmed = table.Column<bool>(type: "boolean", nullable: false),
+                    PasswordHash = table.Column<string>(type: "text", nullable: true),
+                    SecurityStamp = table.Column<string>(type: "text", nullable: true),
+                    ConcurrencyStamp = table.Column<string>(type: "text", nullable: true),
+                    PhoneNumber = table.Column<string>(type: "text", nullable: true),
+                    PhoneNumberConfirmed = table.Column<bool>(type: "boolean", nullable: false),
+                    TwoFactorEnabled = table.Column<bool>(type: "boolean", nullable: false),
+                    LockoutEnd = table.Column<DateTimeOffset>(type: "timestamp with time zone", nullable: true),
+                    LockoutEnabled = table.Column<bool>(type: "boolean", nullable: false),
+                    AccessFailedCount = table.Column<int>(type: "integer", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_AspNetUsers", x => x.Id);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "AspNetRoleClaims",
+                schema: "Identity",
+                columns: table => new
+                {
+                    Id = table.Column<int>(type: "integer", nullable: false)
+                        .Annotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn),
+                    RoleId = table.Column<Guid>(type: "uuid", nullable: false),
+                    ClaimType = table.Column<string>(type: "text", nullable: true),
+                    ClaimValue = table.Column<string>(type: "text", nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_AspNetRoleClaims", x => x.Id);
+                    table.ForeignKey(
+                        name: "FK_AspNetRoleClaims_AspNetRoles_RoleId",
+                        column: x => x.RoleId,
+                        principalSchema: "Identity",
+                        principalTable: "AspNetRoles",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "AspNetUserClaims",
+                schema: "Identity",
+                columns: table => new
+                {
+                    Id = table.Column<int>(type: "integer", nullable: false)
+                        .Annotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn),
+                    UserId = table.Column<Guid>(type: "uuid", nullable: false),
+                    ClaimType = table.Column<string>(type: "text", nullable: true),
+                    ClaimValue = table.Column<string>(type: "text", nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_AspNetUserClaims", x => x.Id);
+                    table.ForeignKey(
+                        name: "FK_AspNetUserClaims_AspNetUsers_UserId",
+                        column: x => x.UserId,
+                        principalSchema: "Identity",
+                        principalTable: "AspNetUsers",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "AspNetUserLogins",
+                schema: "Identity",
+                columns: table => new
+                {
+                    LoginProvider = table.Column<string>(type: "text", nullable: false),
+                    ProviderKey = table.Column<string>(type: "text", nullable: false),
+                    ProviderDisplayName = table.Column<string>(type: "text", nullable: true),
+                    UserId = table.Column<Guid>(type: "uuid", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_AspNetUserLogins", x => new { x.LoginProvider, x.ProviderKey });
+                    table.ForeignKey(
+                        name: "FK_AspNetUserLogins_AspNetUsers_UserId",
+                        column: x => x.UserId,
+                        principalSchema: "Identity",
+                        principalTable: "AspNetUsers",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "AspNetUserRoles",
+                schema: "Identity",
+                columns: table => new
+                {
+                    UserId = table.Column<Guid>(type: "uuid", nullable: false),
+                    RoleId = table.Column<Guid>(type: "uuid", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_AspNetUserRoles", x => new { x.UserId, x.RoleId });
+                    table.ForeignKey(
+                        name: "FK_AspNetUserRoles_AspNetRoles_RoleId",
+                        column: x => x.RoleId,
+                        principalSchema: "Identity",
+                        principalTable: "AspNetRoles",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Cascade);
+                    table.ForeignKey(
+                        name: "FK_AspNetUserRoles_AspNetUsers_UserId",
+                        column: x => x.UserId,
+                        principalSchema: "Identity",
+                        principalTable: "AspNetUsers",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "AspNetUserTokens",
+                schema: "Identity",
+                columns: table => new
+                {
+                    UserId = table.Column<Guid>(type: "uuid", nullable: false),
+                    LoginProvider = table.Column<string>(type: "text", nullable: false),
+                    Name = table.Column<string>(type: "text", nullable: false),
+                    Value = table.Column<string>(type: "text", nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_AspNetUserTokens", x => new { x.UserId, x.LoginProvider, x.Name });
+                    table.ForeignKey(
+                        name: "FK_AspNetUserTokens_AspNetUsers_UserId",
+                        column: x => x.UserId,
+                        principalSchema: "Identity",
+                        principalTable: "AspNetUsers",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateIndex(
+                name: "IX_AspNetRoleClaims_RoleId",
+                schema: "Identity",
+                table: "AspNetRoleClaims",
+                column: "RoleId");
+
+            migrationBuilder.CreateIndex(
+                name: "RoleNameIndex",
+                schema: "Identity",
+                table: "AspNetRoles",
+                column: "NormalizedName",
+                unique: true);
+
+            migrationBuilder.CreateIndex(
+                name: "IX_AspNetUserClaims_UserId",
+                schema: "Identity",
+                table: "AspNetUserClaims",
+                column: "UserId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_AspNetUserLogins_UserId",
+                schema: "Identity",
+                table: "AspNetUserLogins",
+                column: "UserId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_AspNetUserRoles_RoleId",
+                schema: "Identity",
+                table: "AspNetUserRoles",
+                column: "RoleId");
+
+            migrationBuilder.CreateIndex(
+                name: "EmailIndex",
+                schema: "Identity",
+                table: "AspNetUsers",
+                column: "NormalizedEmail");
+
+            migrationBuilder.CreateIndex(
+                name: "UserNameIndex",
+                schema: "Identity",
+                table: "AspNetUsers",
+                column: "NormalizedUserName",
+                unique: true);
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropTable(
+                name: "AspNetRoleClaims",
+                schema: "Identity");
+
+            migrationBuilder.DropTable(
+                name: "AspNetUserClaims",
+                schema: "Identity");
+
+            migrationBuilder.DropTable(
+                name: "AspNetUserLogins",
+                schema: "Identity");
+
+            migrationBuilder.DropTable(
+                name: "AspNetUserRoles",
+                schema: "Identity");
+
+            migrationBuilder.DropTable(
+                name: "AspNetUserTokens",
+                schema: "Identity");
+
+            migrationBuilder.DropTable(
+                name: "AspNetRoles",
+                schema: "Identity");
+
+            migrationBuilder.DropTable(
+                name: "AspNetUsers",
+                schema: "Identity");
+        }
+    }
+}

backend/Modules/Identity/Migrations/IdentityDbContextModelSnapshot.cs

@@ -0,0 +1,312 @@
+// <auto-generated />
+using System;
+using Hutopy.Modules.Identity.Data;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+
+#nullable disable
+
+namespace Hutopy.Modules.Identity.Migrations
+{
+    [DbContext(typeof(IdentityDbContext))]
+    partial class IdentityDbContextModelSnapshot : ModelSnapshot
+    {
+        protected override void BuildModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasDefaultSchema("Identity")
+                .HasAnnotation("ProductVersion", "9.0.3")
+                .HasAnnotation("Relational:MaxIdentifierLength", 63);
+
+            NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
+
+            modelBuilder.Entity("Hutopy.Modules.Identity.Data.Role", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Name")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("NormalizedName")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("NormalizedName")
+                        .IsUnique()
+                        .HasDatabaseName("RoleNameIndex");
+
+                    b.ToTable("AspNetRoles", "Identity");
+                });
+
+            modelBuilder.Entity("Hutopy.Modules.Identity.Data.User", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("AccessFailedCount")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Address")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("Alias")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<DateTime?>("BirthDate")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Email")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<bool>("EmailConfirmed")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("FacebookId")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("Firstname")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("GoogleId")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("Lastname")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<bool>("LockoutEnabled")
+                        .HasColumnType("boolean");
+
+                    b.Property<DateTimeOffset?>("LockoutEnd")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("NormalizedEmail")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("NormalizedUserName")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("PasswordHash")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PhoneNumber")
+                        .HasColumnType("text");
+
+                    b.Property<bool>("PhoneNumberConfirmed")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("PortraitUrl")
+                        .HasMaxLength(2048)
+                        .HasColumnType("character varying(2048)");
+
+                    b.Property<string>("RefreshToken")
+                        .HasMaxLength(44)
+                        .HasColumnType("character varying(44)");
+
+                    b.Property<DateTime>("RefreshTokenExpiryTime")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("SecurityStamp")
+                        .HasColumnType("text");
+
+                    b.Property<bool>("TwoFactorEnabled")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("UserName")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("NormalizedEmail")
+                        .HasDatabaseName("EmailIndex");
+
+                    b.HasIndex("NormalizedUserName")
+                        .IsUnique()
+                        .HasDatabaseName("UserNameIndex");
+
+                    b.ToTable("AspNetUsers", "Identity");
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim<System.Guid>", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("ClaimType")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ClaimValue")
+                        .HasColumnType("text");
+
+                    b.Property<Guid>("RoleId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("RoleId");
+
+                    b.ToTable("AspNetRoleClaims", "Identity");
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserClaim<System.Guid>", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("ClaimType")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ClaimValue")
+                        .HasColumnType("text");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("AspNetUserClaims", "Identity");
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserLogin<System.Guid>", b =>
+                {
+                    b.Property<string>("LoginProvider")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ProviderKey")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ProviderDisplayName")
+                        .HasColumnType("text");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("LoginProvider", "ProviderKey");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("AspNetUserLogins", "Identity");
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserRole<System.Guid>", b =>
+                {
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("RoleId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("UserId", "RoleId");
+
+                    b.HasIndex("RoleId");
+
+                    b.ToTable("AspNetUserRoles", "Identity");
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserToken<System.Guid>", b =>
+                {
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("LoginProvider")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Value")
+                        .HasColumnType("text");
+
+                    b.HasKey("UserId", "LoginProvider", "Name");
+
+                    b.ToTable("AspNetUserTokens", "Identity");
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim<System.Guid>", b =>
+                {
+                    b.HasOne("Hutopy.Modules.Identity.Data.Role", null)
+                        .WithMany()
+                        .HasForeignKey("RoleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserClaim<System.Guid>", b =>
+                {
+                    b.HasOne("Hutopy.Modules.Identity.Data.User", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserLogin<System.Guid>", b =>
+                {
+                    b.HasOne("Hutopy.Modules.Identity.Data.User", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserRole<System.Guid>", b =>
+                {
+                    b.HasOne("Hutopy.Modules.Identity.Data.Role", null)
+                        .WithMany()
+                        .HasForeignKey("RoleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Hutopy.Modules.Identity.Data.User", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserToken<System.Guid>", b =>
+                {
+                    b.HasOne("Hutopy.Modules.Identity.Data.User", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

backend/Modules/Identity/Models/Result.cs

@@ -0,0 +1,49 @@
+namespace Hutopy.Modules.Identity.Models;
+
+public class Result(
+    bool succeeded, 
+    IEnumerable<string> errors)
+{
+    public bool Succeeded { get; init; } = succeeded;
+    public string[] Errors { get; init; } = errors.ToArray();
+    
+    public static Result Success()
+    {
+        return new Result(true, Array.Empty<string>());
+    }
+
+    public static Result Failure(IEnumerable<string> errors)
+    {
+        return new Result(false, errors);
+    }
+}
+
+public class Result<T>(
+    T? value,
+    bool succeeded, 
+    IEnumerable<string> errors)
+{
+    public bool Succeeded { get; init; } = succeeded;
+    public string[] Errors { get; init; } = errors.ToArray();
+    public T? Value { get; set; } = value;
+    
+    public T GetValueOrDefault()
+    {
+        return Value ?? default(T)!;
+    }
+    
+    public string GetErrorsAsString()
+    {
+        return Errors.Length == 0 ? string.Empty : string.Join(", ", Errors);
+    }
+
+    public static Result<T> Success(T value)
+    {
+        return new Result<T>(value, true, Array.Empty<string>());
+    }
+
+    public static Result<T> Failure(T value, IEnumerable<string> errors)
+    {
+        return new Result<T>(value, false, errors);
+    }
+}

backend/Modules/Identity/Models/RoleModel.cs

@@ -0,0 +1,7 @@
+namespace Hutopy.Modules.Identity.Models;
+
+public class RoleModel
+{
+    public Guid Id { get; set; }
+    public string? Name { get; set; }
+}

backend/Modules/Identity/Models/UserDto.cs

@@ -0,0 +1,16 @@
+namespace Hutopy.Modules.Identity.Models;
+
+public class UserDto
+{
+    public Guid Id { get; init; }
+    public IList<string> UserRoles { get; init; } = [];
+    public string Username { get; init; } = null!;
+    public string? Alias { get; init; }
+    public string? PortraitUrl { get; init; }
+    public string? Firstname { get; init; }
+    public string? Lastname { get; init; }
+    public string? Email { get; init; }
+    public string? PhoneNumber { get; init; }
+    public DateTime? BirthDate { get; init; }
+    public string? Address { get; init; }
+}

backend/Modules/Identity/Models/UserModel.cs

@@ -0,0 +1,15 @@
+namespace Hutopy.Modules.Identity.Models;
+
+public class UserModel
+{
+    public Guid Id { get; set; }
+    public string Username { get; init; } = null!;
+    public string? Alias { get; init; }
+    public string? PortraitUrl { get; init; }
+    public string? Firstname { get; init; }
+    public string? Lastname { get; init; }
+    public string? Email { get; init; }
+    public string? PhoneNumber { get; init; }
+    public DateTime? BirthDate { get; init; }
+    public string? Address { get; init; }
+}

backend/Modules/Identity/Services/UserLookup.cs

@@ -0,0 +1,21 @@
+using Hutopy.Modules.Identity.Contracts;
+using Hutopy.Modules.Identity.Data;
+
+namespace Hutopy.Modules.Identity.Services;
+
+public sealed class UserLookup(
+    UserManager userManager)
+    : IUserLookup
+{
+    public async Task<UserReference?> GetUserAsync(Guid userId, CancellationToken cancellationToken = default)
+    {
+        var user = await userManager.FindByIdAsync(userId.ToString());
+
+        return user is null
+            ? null
+            : new UserReference(
+                user.Id,
+                user.Fullname,
+                user.PortraitUrl);
+    }
+}

backend/Modules/Memberships/Contracts/IMembershipCancellationProcessor.cs

@@ -0,0 +1,6 @@
+namespace Hutopy.Modules.Memberships.Contracts;
+
+public interface IMembershipCancellationProcessor
+{
+    Task<DateTimeOffset?> CancelAsync(string subscriptionId, CancellationToken ct = default);
+}

backend/Modules/Memberships/Contracts/IMembershipNotifier.cs

@@ -0,0 +1,26 @@
+namespace Hutopy.Modules.Memberships.Contracts;
+
+public interface IMembershipNotifier
+{
+    Task NotifyCheckoutSessionCompleted(string stripeSessionId, string stripeSubscriptionId,
+        string userId,
+        string creatorId,
+        string tierId,
+        CancellationToken cancellationToken = default);
+
+    Task NotifyPaymentSucceedAsync(
+        string stripeSubscriptionId,
+        string hostedInvoiceUrl,
+        decimal amount,
+        string currency,
+        CancellationToken cancellationToken = default);
+
+    Task NotifySubscriptionUpdatedAsync(
+        string subscriptionId,
+        DateTimeOffset? endDate,
+        CancellationToken cancellationToken = default);
+
+    Task NotifySubscriptionDeletedAsync(
+        string subscriptionId,
+        CancellationToken cancellationToken = default);
+}

backend/Modules/Memberships/Contracts/IMembershipPaymentProcessor.cs

@@ -0,0 +1,14 @@
+using Hutopy.Modules.Creators.Contracts;
+
+namespace Hutopy.Modules.Memberships.Contracts;
+
+public interface IMembershipPaymentProcessor
+{
+    Task<MembershipCheckoutSession> CreateCheckoutSessionAsync(
+        Guid userId,
+        CreatorReference creatorReference,
+        Guid tierId,
+        string priceId,
+        string successUrl,
+        string cancelUrl);
+}

backend/Modules/Memberships/Contracts/IMembershipTierProcessor.cs

@@ -0,0 +1,11 @@
+namespace Hutopy.Modules.Memberships.Contracts;
+
+public interface IMembershipTierProcessor
+{
+    Task<string> CreateAsync(
+        Guid creatorId,
+        Guid tierId,
+        string productName,
+        string currencyCode,
+        decimal amount);
+}

backend/Modules/Memberships/Contracts/MembershipCheckoutSession.cs

@@ -0,0 +1,6 @@
+namespace Hutopy.Modules.Memberships.Contracts;
+
+[PublicAPI]
+public record MembershipCheckoutSession(
+    string Id,
+    string Url);

backend/Modules/Memberships/Data/Membership.cs

@@ -0,0 +1,20 @@
+using System.ComponentModel.DataAnnotations;
+
+namespace Hutopy.Modules.Memberships.Data;
+
+public class Membership
+{
+    public Guid Id { get; set; }
+    public DateTimeOffset CreatedAt { get; set; }
+    public Guid UserId { get; set; }
+    public Guid CreatorId { get; set; }
+    public Guid TierId { get; set; }
+    public MembershipTier? MembershipTier { get; set; }
+    public MembershipState State { get; set; }
+    public DateTimeOffset? StartDate { get; set; }
+    public DateTimeOffset? EndDate { get; set; }
+    public bool IsActive => EndDate == null || EndDate > DateTimeOffset.UtcNow;
+    [MaxLength(256)]public string? StripeSubscriptionId { get; set; }
+    
+    public ICollection<Payment> Payments { get; set; } = [];
+}

backend/Modules/Memberships/Data/MembershipState.cs

@@ -0,0 +1,8 @@
+namespace Hutopy.Modules.Memberships.Data;
+
+public enum MembershipState
+{
+    Pending,
+    Active,
+    Inactive
+}

backend/Modules/Memberships/Data/MembershipTier.cs

@@ -0,0 +1,17 @@
+using System.ComponentModel.DataAnnotations;
+using Hutopy.Common.Domain;
+
+namespace Hutopy.Modules.Memberships.Data;
+
+public class MembershipTier : Entity
+{
+    public Guid CreatorId { get; set; }
+    [MaxLength(128)] public string Name { get; set; } = null!;
+    [MaxLength(4096)] public string Description { get; set; } = null!;
+    public decimal Price { get; set; }
+    [MaxLength(128)] public string CurrencyCode { get; set; } = null!;
+    [MaxLength(128)] public string StripeProductId { get; set; } = null!;
+    [MaxLength(128)] public string StripePriceId { get; set; } = null!;
+
+    public ICollection<Membership> Subscriptions { get; set; } = [];
+}

backend/Modules/Memberships/Data/MembershipsDbContext.cs

@@ -0,0 +1,36 @@
+namespace Hutopy.Modules.Memberships.Data;
+
+public sealed class MembershipsDbContext(
+    DbContextOptions<MembershipsDbContext> options)
+    : DbContext(options)
+{
+    public const string SchemaName = "Memberships";
+
+    public DbSet<MembershipTier> MembershipTiers => Set<MembershipTier>();
+    public DbSet<Membership> Memberships => Set<Membership>();
+    public DbSet<Payment> Payments => Set<Payment>();
+    
+    
+    protected override void OnModelCreating(ModelBuilder modelBuilder)
+    {
+        modelBuilder.HasDefaultSchema(SchemaName);
+
+        modelBuilder
+            .Entity<MembershipTier>()
+            .Property(c => c.CreatedAt)
+            .ValueGeneratedOnAdd()
+            .HasDefaultValueSql("CURRENT_TIMESTAMP");
+        
+        modelBuilder
+            .Entity<Membership>()
+            .Property(c => c.CreatedAt)
+            .ValueGeneratedOnAdd()
+            .HasDefaultValueSql("CURRENT_TIMESTAMP");
+
+        modelBuilder
+            .Entity<Payment>()
+            .Property(c => c.CreatedAt)
+            .ValueGeneratedOnAdd()
+            .HasDefaultValueSql("CURRENT_TIMESTAMP");
+    }
+}

backend/Modules/Memberships/Data/Payment.cs

@@ -0,0 +1,13 @@
+using System.ComponentModel.DataAnnotations;
+
+namespace Hutopy.Modules.Memberships.Data;
+
+public class Payment
+{
+    public Guid Id { get; set; }
+    public DateTimeOffset CreatedAt { get; set; }
+    public decimal Amount { get; set; }
+    [MaxLength(8)] public required string Currency { get; set; }
+    [MaxLength(2048)] public required string InvoiceUrl { get; set; }
+    
+}

backend/Modules/Memberships/DependencyInjection.cs

@@ -0,0 +1,32 @@
+using Hutopy.Modules.Memberships.Contracts;
+using Hutopy.Modules.Memberships.Data;
+using Hutopy.Modules.Memberships.Services;
+
+namespace Hutopy.Modules.Memberships;
+
+public static class DependencyInjection
+{
+    public static WebApplicationBuilder AddMembershipModule(
+        this WebApplicationBuilder builder,
+        Action<DbContextOptionsBuilder>? configureAction = null)
+    {
+        builder.Services.AddDbContext<MembershipsDbContext>(configureAction);
+
+        builder.Services.AddTransient<IMembershipNotifier, MembershipNotifier>();
+        
+        return builder;
+    }
+    
+    
+    public static async Task<IApplicationBuilder> UseMembershipModuleAsync(
+        this IApplicationBuilder app,
+        CancellationToken cancellationToken = default)
+    {
+        var scopeFactory = app.ApplicationServices.GetRequiredService<IServiceScopeFactory>();
+        using var scope = scopeFactory.CreateScope();
+        await using var context = scope.ServiceProvider.GetRequiredService<MembershipsDbContext>();
+        await context.Database.MigrateAsync(cancellationToken: cancellationToken);
+
+        return app;
+    }
+}

backend/Modules/Memberships/Handlers/CancelMembership.cs

@@ -0,0 +1,49 @@
+using Hutopy.Modules.Memberships.Contracts;
+using Hutopy.Modules.Memberships.Data;
+
+namespace Hutopy.Modules.Memberships.Handlers;
+
+[PublicAPI]
+public class CancelMembershipRequest
+{
+    public Guid SubscriptionId { get; set; }
+}
+
+public class CancelMembershipHandler(
+    MembershipsDbContext dbContext,
+    IMembershipCancellationProcessor cancellationProcessor)
+    : Endpoint<CancelMembershipRequest>
+{
+    public override void Configure()
+    {
+        Delete("/api/memberships");
+        Options(o => o.WithTags("Memberships"));
+    }
+    
+    public override async Task HandleAsync(
+        CancelMembershipRequest req,
+        CancellationToken ct)
+    {
+        var subscription = await dbContext
+            .Memberships
+            .FindAsync(
+                [req.SubscriptionId],
+                cancellationToken: ct);
+
+        if (subscription is not { EndDate: null } 
+            || subscription.StripeSubscriptionId is null)
+        {
+            await SendNotFoundAsync(ct);
+            return;
+        }
+
+        // Cancel Stripe subscription
+        await cancellationProcessor.CancelAsync(subscription.StripeSubscriptionId, ct);
+
+        // Update subscription in the system
+        subscription.EndDate = DateTime.UtcNow;
+        await dbContext.SaveChangesAsync(ct);
+
+        await SendOkAsync(subscription.Id, ct);
+    }
+}

backend/Modules/Memberships/Handlers/CreateMembershipTier.cs

@@ -0,0 +1,56 @@
+using Hutopy.Modules.Memberships.Contracts;
+using Hutopy.Modules.Memberships.Data;
+
+namespace Hutopy.Modules.Memberships.Handlers;
+
+[PublicAPI]
+public record struct CreateMembershipTierRequest(
+    Guid CreatorId,
+    string Name,
+    string Description,
+    decimal Price,
+    string Currency = "CAD");
+
+[PublicAPI]
+public class CreateMembershipTierEndpoint(
+    MembershipsDbContext dbContext,
+    IMembershipTierProcessor membershipTierProcessor)
+    : Endpoint<CreateMembershipTierRequest>
+{
+    public override void Configure()
+    {
+        Post("/api/memberships/tiers");
+        Options(o => o.WithTags("Memberships"));
+    }
+
+    public override async Task HandleAsync(
+        CreateMembershipTierRequest req,
+        CancellationToken ct)
+    {
+        var tierId = Guid.CreateVersion7();
+
+        var productId = await membershipTierProcessor.CreateAsync(
+            req.CreatorId,
+            tierId,
+            req.Name,
+            req.Currency,
+            req.Price);
+
+        // Record the new Tier
+        var tier = new MembershipTier
+        {
+            Id = tierId,
+            CreatorId = req.CreatorId,
+            Price = req.Price,
+            Name = req.Name,
+            Description = req.Description,
+            StripeProductId = productId,
+        };
+
+        dbContext.MembershipTiers.Add(tier);
+
+        await dbContext.SaveChangesAsync(ct);
+
+        await SendOkAsync(tier, ct);
+    }
+}

backend/Modules/Memberships/Handlers/GetActiveMemberships.cs

@@ -0,0 +1,54 @@
+using Hutopy.Infrastructure.Security;
+using Hutopy.Modules.Creators.Contracts;
+using Hutopy.Modules.Memberships.Data;
+
+namespace Hutopy.Modules.Memberships.Handlers;
+
+[PublicAPI]
+public record struct GetActiveMembershipsResponse(
+    Guid Id,
+    Guid CreatorId,
+    string CreatorName,
+    string CreatorPortraitUrl,
+    DateTimeOffset? StartDate,
+    DateTimeOffset? EndDate);
+
+[PublicAPI]
+public class GetActiveMembershipsHandler(
+    ICreatorLookup creatorLookup,
+    MembershipsDbContext dbContext)
+    : EndpointWithoutRequest<IEnumerable<GetActiveMembershipsResponse>>
+{
+    public override void Configure()
+    {
+        Get("/api/memberships/active");
+        Options(o => o.WithTags("Memberships"));
+    }
+
+    public override async Task HandleAsync(
+        CancellationToken ct)
+    {
+        var subscriptions = await dbContext
+            .Memberships
+            .Where(subscription => subscription.UserId == User.GetUserId())
+            .Where(subscription => subscription.State == MembershipState.Active)
+            .ToListAsync(ct);
+
+        var result = await Task.WhenAll(
+            subscriptions.Select(async subscription =>
+            {
+                var creator = await creatorLookup.GetCreatorAsync(subscription.CreatorId, ct);
+
+                return new GetActiveMembershipsResponse(
+                    subscription.Id,
+                    subscription.CreatorId,
+                    creator?.Name ?? "Unknown Creator",
+                    creator?.PortraitUrl ?? string.Empty,
+                    subscription.StartDate,
+                    subscription.EndDate);
+            }));
+
+
+        await SendOkAsync(result, ct);
+    }
+}

backend/Modules/Memberships/Handlers/GetMembershipTiers.cs

@@ -0,0 +1,52 @@
+using Hutopy.Modules.Memberships.Data;
+
+namespace Hutopy.Modules.Memberships.Handlers;
+
+[PublicAPI]
+public record GetMembershipTiersRequest
+{ 
+    public Guid CreatorId { get; set; }
+}
+
+[PublicAPI]
+public record struct TierModel(
+    Guid Id,
+    DateTimeOffset CreatedAt,
+    string Name,
+    string Description,
+    decimal Price,
+    string CurrencyCode,
+    string StripeProductId);
+
+[PublicAPI]
+public class GetMembershipTiersEndpoint(
+    MembershipsDbContext dbContext)
+    : Endpoint<GetMembershipTiersRequest, List<TierModel>>
+{
+    public override void Configure()
+    {
+        Get("/api/memberships/tiers/{CreatorId:guid}");
+        Options(o => o.WithTags("Memberships"));
+        AllowAnonymous();
+    }
+
+    public override async Task HandleAsync(
+        GetMembershipTiersRequest req,
+        CancellationToken ct)
+    {
+        var tiers = await dbContext
+            .MembershipTiers
+            .Where(tier => tier.CreatorId == req.CreatorId)
+            .Select(tier => new TierModel(
+                tier.Id,
+                tier.CreatedAt,
+                tier.Name,
+                tier.Description,
+                tier.Price,
+                tier.CurrencyCode,
+                tier.StripeProductId))
+            .ToListAsync(ct);
+
+        await SendOkAsync(tiers, ct);
+    }
+}