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);