Update packages

backend/Core/Musify.Application/Configuration/PlayListConfiguration.cs

@@ -12,10 +12,6 @@ namespace Musify.Application.Configuration
 
         [Required]
         public PlayListPicturesSizes PicturesSizes { get; set; } = new PlayListPicturesSizes();
-
-        public bool SeedPresetPictures { get; set; } = true;
-
-        public bool OverwritePresetPictures { get; set; } = false;
     }
 
     public class PlayListRoutes
@@ -38,18 +34,6 @@ namespace Musify.Application.Configuration
         [Required]
         public string LargePicturesFolder { get; set; } = "LargePictures";
 
-        [Required]
-        public string PresetOriginalPicture { get; set; } = "PresetOriginalPicture.webp";
-
-        [Required]
-        public string PresetSmallPicture { get; set; } = "PresetSmallPicture.webp";
-
-        [Required]
-        public string PresetMediumPicture { get; set; } = "PresetMediumPicture.webp";
-
-        [Required]
-        public string PresetLargePicture { get; set; } = "PresetLargePicture.webp";
-
         public string SmallPicturesPath => StorageKey.Combine(ParentFolders, SmallPicturesFolder);
 
         public string MediumPicturesPath => StorageKey.Combine(ParentFolders, MediumPicturesFolder);
@@ -58,12 +42,6 @@ namespace Musify.Application.Configuration
 
         public string OriginalPicturesPath => StorageKey.Combine(ParentFolders, OriginalPicturesFolder);
 
-        public string PresetSmallPicturePath => StorageKey.Combine(ParentFolders, SmallPicturesFolder, PresetSmallPicture);
-
-        public string PresetMediumPicturePath => StorageKey.Combine(ParentFolders, MediumPicturesFolder, PresetMediumPicture);
-
-        public string PresetLargePicturePath => StorageKey.Combine(ParentFolders, LargePicturesFolder, PresetLargePicture);
-
         public string BuildOriginalPicturePath(string pictureName) => StorageKey.Combine(ParentFolders, OriginalPicturesFolder, pictureName);
 
         public string BuildOriginalPicturePath(long userId, string pictureName) => StorageKey.Combine(UploadsFolder, userId.ToString(), ParentFolders, OriginalPicturesFolder, pictureName);

backend/Core/Musify.Application/PlayLists/CreatePlayList.cs

@@ -31,7 +31,7 @@ namespace Musify.Application.PlayLists
         UploadIntentConfiguration uploadIntentConfiguration)
         : ICommandHandler<CreatePlayListCommand, ErrorOr<PlayListApplicationResponse>>
     {
-        private sealed record ResolvedPlayListPictures(PlayListPictures Pictures, UploadIntent? Intent);
+        private sealed record ResolvedPlayListPictures(PlayListPictures? Pictures, UploadIntent? Intent);
 
         public async ValueTask<ErrorOr<PlayListApplicationResponse>> Handle(CreatePlayListCommand request, CancellationToken cancellationToken)
         {
@@ -63,7 +63,7 @@ namespace Musify.Application.PlayLists
 
             if (resolvedPictures.Intent != null)
             {
-                var finalPictureKey = playListConfiguration.Routes.BuildOriginalPicturePath(request.UserId, resolvedPictures.Pictures.OriginalName);
+                var finalPictureKey = playListConfiguration.Routes.BuildOriginalPicturePath(request.UserId, resolvedPictures.Pictures!.OriginalName);
                 var publishResult = await PublishCreatePlayListEventAsync(playList.Id, resolvedPictures.Intent, finalPictureKey, cancellationToken);
                 if (publishResult.IsError)
                     return publishResult.Errors;
@@ -88,13 +88,7 @@ namespace Musify.Application.PlayLists
         {
             if (!request.PictureIntentId.HasValue)
             {
-                return new ResolvedPlayListPictures(new PlayListPictures
-                {
-                    OriginalName = playListConfiguration.Routes.PresetOriginalPicture,
-                    SmallName = playListConfiguration.Routes.PresetSmallPicture,
-                    MediumName = playListConfiguration.Routes.PresetMediumPicture,
-                    LargeName = playListConfiguration.Routes.PresetLargePicture
-                }, null);
+                return new ResolvedPlayListPictures(null, null);
             }
 
             var validation = await uploadIntentValidator.ValidateAndLoadAsync(
@@ -103,12 +97,12 @@ namespace Musify.Application.PlayLists
             if (validation.IsError)
                 return validation.Errors;
 
-            return new ResolvedPlayListPictures(new PlayListPictures 
-            { 
+            return new ResolvedPlayListPictures(new PlayListPictures
+            {
                 OriginalName = validation.Value.ObjectName,
-                SmallName = playListConfiguration.Routes.PresetSmallPicture,
-                MediumName = playListConfiguration.Routes.PresetMediumPicture,
-                LargeName = playListConfiguration.Routes.PresetLargePicture
+                SmallName = validation.Value.ObjectName,
+                MediumName = validation.Value.ObjectName,
+                LargeName = validation.Value.ObjectName
             }, validation.Value);
         }
 

backend/Core/Musify.Application/PlayLists/UpdatePlayList.cs

@@ -75,12 +75,12 @@ namespace Musify.Application.PlayLists
                     return validation.Errors;
 
                 pictureIntent = validation.Value;
-                playListEntity.Pictures = new PlayListPictures 
-                { 
+                playListEntity.Pictures = new PlayListPictures
+                {
                     OriginalName = pictureIntent.ObjectName,
-                    SmallName = playListConfiguration.Routes.PresetSmallPicture,
-                    MediumName = playListConfiguration.Routes.PresetMediumPicture,
-                    LargeName = playListConfiguration.Routes.PresetLargePicture
+                    SmallName = pictureIntent.ObjectName,
+                    MediumName = pictureIntent.ObjectName,
+                    LargeName = pictureIntent.ObjectName
                 };
                 finalPictureKey = playListConfiguration.Routes.BuildOriginalPicturePath(request.UserId, pictureIntent.ObjectName);
             }

backend/Core/Musify.Application/Tracks/GetLastTrackListenedByUserId.cs

@@ -0,0 +1,29 @@
+using ErrorOr;
+using Mediator;
+using Microsoft.EntityFrameworkCore;
+using Musify.Application.Contracts;
+using Musify.Application.Tracks.Responses;
+
+namespace Musify.Application.Tracks
+{
+    public record GetLastTrackListenedByUserIdQuery(long UserId) : IQuery<ErrorOr<TrackApplicationResponse>>;
+
+    public class GetLastTrackListenedByUserIdQueryHandler(IDatabase database)
+        : IQueryHandler<GetLastTrackListenedByUserIdQuery, ErrorOr<TrackApplicationResponse>>
+    {
+        public async ValueTask<ErrorOr<TrackApplicationResponse>> Handle(GetLastTrackListenedByUserIdQuery query, CancellationToken cancellationToken)
+        {
+            var track = await database.ListeningHistories
+                .Include(t => t.Track.Owner)
+                .Include(t => t.Track.Tags)
+                .Where(t => t.UserId == query.UserId)
+                .OrderByDescending(t => t.ListenedAt)
+                .Select(t => TrackApplicationResponse.FromEntity(t.Track, t.Track.ListeningHistories.Count))
+                .FirstOrDefaultAsync(cancellationToken);
+
+            return track == null
+                ? Error.NotFound("Track.NotFound", "No track found for the given user ID.")
+                : track;
+        }
+    }
+}

backend/Core/Musify.Application/Tracks/GetTracks.cs

@@ -33,7 +33,7 @@ namespace Musify.Application.Tracks
             var pagedEntities = await tracksQuery
                 .OrderByDescending(t => t.Track.CreatedAt)
                 .ThenBy(t => t.Id)
-                .Select(t => new { t.Track, ListensCount = t.Track.ListeningHistories.Count })
+                .Select(t => new { t.Track, ListensCount = t.Track.ListeningHistories.Count } )
                 .ToPagedListAsync(request.PageNumber, request.PageSize, totalCount, cancellationToken);
 
             var items = pagedEntities

backend/Core/Musify.Domain/Entities/PlayList.cs

@@ -27,8 +27,7 @@ namespace Musify.Domain.Entities
         [MaxLength(256)]
         public string? Description { get; set; }
 
-        [Required]
-        public required PlayListPictures Pictures { get; set; }
+        public PlayListPictures? Pictures { get; set; }
 
         [Required]
         public LifeCycleStatus LifeCycleStatus { get; set; } = LifeCycleStatus.Active;

backend/Core/Musify.Infrastructure/Infrastructure.csproj

@@ -44,8 +44,4 @@
     <Folder Include="Persistence\Migrations\" />
   </ItemGroup>
 
-  <ItemGroup>
-    <EmbeddedResource Include="Assets\PlayListDefaultCover.png" LogicalName="Musify.Infrastructure.Assets.PlayListDefaultCover.png" />
-  </ItemGroup>
-
 </Project>

backend/Core/Musify.Infrastructure/Persistence/Database.cs

@@ -67,10 +67,10 @@ namespace Musify.Infrastructure.Persistence
             modelBuilder.Entity<PlayList>()
                 .OwnsOne(playList => playList.Pictures, pictures =>
                 {
-                    pictures.Property(p => p.OriginalName).HasColumnName("OriginalPictureName").HasMaxLength(64);
-                    pictures.Property(p => p.SmallName).HasColumnName("SmallPictureName").HasMaxLength(64);
-                    pictures.Property(p => p.MediumName).HasColumnName("MediumPictureName").HasMaxLength(64);
-                    pictures.Property(p => p.LargeName).HasColumnName("LargePictureName").HasMaxLength(64);
+                    pictures.Property(p => p.OriginalName).HasColumnName("OriginalPictureName").HasMaxLength(64).IsRequired(false);
+                    pictures.Property(p => p.SmallName).HasColumnName("SmallPictureName").HasMaxLength(64).IsRequired(false);
+                    pictures.Property(p => p.MediumName).HasColumnName("MediumPictureName").HasMaxLength(64).IsRequired(false);
+                    pictures.Property(p => p.LargeName).HasColumnName("LargePictureName").HasMaxLength(64).IsRequired(false);
                 });
             modelBuilder.Entity<PlayList>().Navigation(playList => playList.Pictures).IsRequired(false);
 

backend/Core/Musify.Infrastructure/Persistence/Migrations/20260917195334_MakePlayListPictureColumnsOptional.cs

@@ -0,0 +1,106 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace Musify.Infrastructure.Persistence.Migrations
+{
+    /// <inheritdoc />
+    public partial class MakePlayListPictureColumnsOptional : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AlterColumn<string>(
+                name: "SmallPictureName",
+                table: "PlayLists",
+                type: "character varying(64)",
+                maxLength: 64,
+                nullable: true,
+                oldClrType: typeof(string),
+                oldType: "character varying(64)",
+                oldMaxLength: 64,
+                oldNullable: true);
+
+            migrationBuilder.AlterColumn<string>(
+                name: "OriginalPictureName",
+                table: "PlayLists",
+                type: "character varying(64)",
+                maxLength: 64,
+                nullable: true,
+                oldClrType: typeof(string),
+                oldType: "character varying(64)",
+                oldMaxLength: 64,
+                oldNullable: true);
+
+            migrationBuilder.AlterColumn<string>(
+                name: "MediumPictureName",
+                table: "PlayLists",
+                type: "character varying(64)",
+                maxLength: 64,
+                nullable: true,
+                oldClrType: typeof(string),
+                oldType: "character varying(64)",
+                oldMaxLength: 64,
+                oldNullable: true);
+
+            migrationBuilder.AlterColumn<string>(
+                name: "LargePictureName",
+                table: "PlayLists",
+                type: "character varying(64)",
+                maxLength: 64,
+                nullable: true,
+                oldClrType: typeof(string),
+                oldType: "character varying(64)",
+                oldMaxLength: 64,
+                oldNullable: true);
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AlterColumn<string>(
+                name: "SmallPictureName",
+                table: "PlayLists",
+                type: "character varying(64)",
+                maxLength: 64,
+                nullable: true,
+                oldClrType: typeof(string),
+                oldType: "character varying(64)",
+                oldMaxLength: 64,
+                oldNullable: true);
+
+            migrationBuilder.AlterColumn<string>(
+                name: "OriginalPictureName",
+                table: "PlayLists",
+                type: "character varying(64)",
+                maxLength: 64,
+                nullable: true,
+                oldClrType: typeof(string),
+                oldType: "character varying(64)",
+                oldMaxLength: 64,
+                oldNullable: true);
+
+            migrationBuilder.AlterColumn<string>(
+                name: "MediumPictureName",
+                table: "PlayLists",
+                type: "character varying(64)",
+                maxLength: 64,
+                nullable: true,
+                oldClrType: typeof(string),
+                oldType: "character varying(64)",
+                oldMaxLength: 64,
+                oldNullable: true);
+
+            migrationBuilder.AlterColumn<string>(
+                name: "LargePictureName",
+                table: "PlayLists",
+                type: "character varying(64)",
+                maxLength: 64,
+                nullable: true,
+                oldClrType: typeof(string),
+                oldType: "character varying(64)",
+                oldMaxLength: 64,
+                oldNullable: true);
+        }
+    }
+}

backend/Core/Musify.Infrastructure/Persistence/Migrations/DatabaseModelSnapshot.cs

@@ -896,25 +896,21 @@ namespace Musify.Infrastructure.Persistence.Migrations
                                 .HasColumnType("uuid");
 
                             b1.Property<string>("LargeName")
-                                .IsRequired()
                                 .HasMaxLength(64)
                                 .HasColumnType("character varying(64)")
                                 .HasColumnName("LargePictureName");
 
                             b1.Property<string>("MediumName")
-                                .IsRequired()
                                 .HasMaxLength(64)
                                 .HasColumnType("character varying(64)")
                                 .HasColumnName("MediumPictureName");
 
                             b1.Property<string>("OriginalName")
-                                .IsRequired()
                                 .HasMaxLength(64)
                                 .HasColumnType("character varying(64)")
                                 .HasColumnName("OriginalPictureName");
 
                             b1.Property<string>("SmallName")
-                                .IsRequired()
                                 .HasMaxLength(64)
                                 .HasColumnType("character varying(64)")
                                 .HasColumnName("SmallPictureName");

backend/Core/Musify.Infrastructure/Services/PlayListPresetSeeder.cs

@@ -1,85 +0,0 @@
-using System.Reflection;
-using Microsoft.Extensions.DependencyInjection;
-using Microsoft.Extensions.Hosting;
-using Microsoft.Extensions.Logging;
-using Musify.Application.Configuration;
-using Musify.Application.Contracts;
-
-namespace Musify.Infrastructure.Services
-{
-    public class PlayListPresetSeeder(IServiceScopeFactory scopeFactory, ILogger<PlayListPresetSeeder> logger)
-        : BackgroundService
-    {
-        private const string SourceResourceName = "Musify.Infrastructure.Assets.PlayListDefaultCover.png";
-        private const string WebpContentType = "image/webp";
-
-        protected override async Task ExecuteAsync(CancellationToken stoppingToken)
-        {
-            using var scope = scopeFactory.CreateScope();
-            var services = scope.ServiceProvider;
-
-            var playListConfiguration = services.GetRequiredService<PlayListConfiguration>();
-            if (!playListConfiguration.SeedPresetPictures)
-                return;
-
-            try
-            {
-                await SeedAsync(services, playListConfiguration, stoppingToken);
-            }
-            catch (Exception exception)
-            {
-                logger.LogError(exception, "Failed to seed playlist preset pictures");
-            }
-        }
-
-        private async Task SeedAsync(IServiceProvider services, PlayListConfiguration configuration, CancellationToken cancellationToken)
-        {
-            var storage = services.GetRequiredService<IStorageService>();
-            var pictures = services.GetRequiredService<IPictureService>();
-            var bucket = services.GetRequiredService<ApplicationStorageConfiguration>().Bucket;
-
-            var source = LoadSourceBytes();
-
-            var routes = configuration.Routes;
-            var sizes = configuration.PicturesSizes;
-
-            var targets = new (string Key, int Width, int Height)[]
-            {
-                (routes.BuildOriginalPicturePath(routes.PresetOriginalPicture), sizes.LargePictureWidth, sizes.LargePictureHeight),
-                (routes.PresetSmallPicturePath, sizes.SmallPictureWidth, sizes.SmallPictureHeight),
-                (routes.PresetMediumPicturePath, sizes.MediumPictureWidth, sizes.MediumPictureHeight),
-                (routes.PresetLargePicturePath, sizes.LargePictureWidth, sizes.LargePictureHeight),
-            };
-
-            foreach (var target in targets)
-            {
-                if (!configuration.OverwritePresetPictures)
-                {
-                    var existing = await storage.HeadObjectAsync(bucket, target.Key, cancellationToken);
-                    if (existing is not null)
-                    {
-                        logger.LogDebug("Playlist preset picture already present at {Bucket}/{Key}", bucket, target.Key);
-                        continue;
-                    }
-                }
-
-                using var sourceStream = new MemoryStream(source, writable: false);
-                await using var resized = await pictures.ResizePictureAsWebpAsync(sourceStream, target.Width, target.Height, cancellationToken);
-                await storage.UploadFileAsync(resized, WebpContentType, bucket, target.Key, cancellationToken);
-
-                logger.LogInformation("Seeded playlist preset picture {Bucket}/{Key} ({Width}x{Height})", bucket, target.Key, target.Width, target.Height);
-            }
-        }
-
-        private static byte[] LoadSourceBytes()
-        {
-            var assembly = Assembly.GetExecutingAssembly();
-            using var stream = assembly.GetManifestResourceStream(SourceResourceName)
-                ?? throw new InvalidOperationException($"Embedded resource '{SourceResourceName}' was not found.");
-
-            using var memory = new MemoryStream();
-            stream.CopyTo(memory);
-            return memory.ToArray();
-        }
-    }
-}

backend/Core/Musify.Infrastructure/Services/ServicesDependencyInjection.cs

@@ -46,12 +46,6 @@ namespace Musify.Infrastructure.Services
             return serviceDescriptors;
         }
 
-        public static IServiceCollection AddPlayListPresetSeeder(this IServiceCollection serviceDescriptors, IConfiguration configuration)
-        {
-            serviceDescriptors.AddHostedService<PlayListPresetSeeder>();
-            return serviceDescriptors;
-        }
-
         public static IServiceCollection AddUploadIntentConfiguration(this IServiceCollection serviceDescriptors, IConfiguration configuration)
         {
             serviceDescriptors.AddValidatedOptions<UploadIntentConfiguration>(configuration, UploadIntentConfiguration.SectionName);

backend/Directory.Packages.props

@@ -1,68 +1,64 @@
 <Project>
-
   <PropertyGroup>
     <ManagePackageVersionsCentrally>true</ManagePackageVersionsCentrally>
   </PropertyGroup>
-
   <ItemGroup>
-    <PackageVersion Include="AWSSDK.S3" Version="4.0.23.4" />
+    <PackageVersion Include="AWSSDK.S3" Version="4.0.103.3" />
     <PackageVersion Include="DispatchR.Mediator" Version="2.2.0" />
     <PackageVersion Include="ErrorOr" Version="2.1.1" />
     <PackageVersion Include="FluentValidation.DependencyInjectionExtensions" Version="12.1.1" />
-    <PackageVersion Include="Hangfire.NetCore" Version="1.8.24" />
+    <PackageVersion Include="Hangfire.NetCore" Version="1.8.25" />
     <PackageVersion Include="Hangfire.PostgreSql" Version="1.21.1" />
     <PackageVersion Include="MassTransit" Version="8.5.9" />
     <PackageVersion Include="MassTransit.EntityFrameworkCore" Version="8.5.9" />
     <PackageVersion Include="MassTransit.RabbitMQ" Version="8.5.9" />
     <PackageVersion Include="Mediator.Abstractions" Version="3.0.2" />
     <PackageVersion Include="Mediator.SourceGenerator" Version="3.0.2" />
-    <PackageVersion Include="Microsoft.AspNetCore.Authentication.JwtBearer" Version="10.0.8" />
-    <PackageVersion Include="Microsoft.AspNetCore.OpenApi" Version="10.0.8" />
-    <PackageVersion Include="Microsoft.EntityFrameworkCore" Version="10.0.8" />
-    <PackageVersion Include="Microsoft.EntityFrameworkCore.Design" Version="10.0.8" />
-    <PackageVersion Include="Microsoft.EntityFrameworkCore.Relational" Version="10.0.8" />
-    <PackageVersion Include="Microsoft.Extensions.Caching.Memory" Version="10.0.8" />
-    <PackageVersion Include="Microsoft.Extensions.Configuration" Version="10.0.8" />
-    <PackageVersion Include="Microsoft.Extensions.Configuration.Binder" Version="10.0.8" />
-    <PackageVersion Include="Microsoft.Extensions.Configuration.FileExtensions" Version="10.0.8" />
-    <PackageVersion Include="Microsoft.Extensions.Configuration.Json" Version="10.0.8" />
-    <PackageVersion Include="Microsoft.Extensions.Configuration.UserSecrets" Version="10.0.8" />
-    <PackageVersion Include="Microsoft.Extensions.Hosting" Version="10.0.8" />
-    <PackageVersion Include="Microsoft.Extensions.Options.ConfigurationExtensions" Version="10.0.8" />
-    <PackageVersion Include="Microsoft.Extensions.Options.DataAnnotations" Version="10.0.8" />
-    <PackageVersion Include="Microsoft.IdentityModel.JsonWebTokens" Version="8.14.0" />
-    <PackageVersion Include="Microsoft.OpenApi" Version="2.9.0" />
+    <PackageVersion Include="Microsoft.AspNetCore.Authentication.JwtBearer" Version="10.0.12" />
+    <PackageVersion Include="Microsoft.AspNetCore.OpenApi" Version="10.0.12" />
+    <PackageVersion Include="Microsoft.EntityFrameworkCore" Version="10.0.12" />
+    <PackageVersion Include="Microsoft.EntityFrameworkCore.Design" Version="10.0.12" />
+    <PackageVersion Include="Microsoft.EntityFrameworkCore.Relational" Version="10.0.12" />
+    <PackageVersion Include="Microsoft.Extensions.Caching.Memory" Version="10.0.12" />
+    <PackageVersion Include="Microsoft.Extensions.Configuration" Version="10.0.12" />
+    <PackageVersion Include="Microsoft.Extensions.Configuration.Binder" Version="10.0.12" />
+    <PackageVersion Include="Microsoft.Extensions.Configuration.FileExtensions" Version="10.0.12" />
+    <PackageVersion Include="Microsoft.Extensions.Configuration.Json" Version="10.0.12" />
+    <PackageVersion Include="Microsoft.Extensions.Configuration.UserSecrets" Version="10.0.12" />
+    <PackageVersion Include="Microsoft.Extensions.Hosting" Version="10.0.12" />
+    <PackageVersion Include="Microsoft.Extensions.Options.ConfigurationExtensions" Version="10.0.12" />
+    <PackageVersion Include="Microsoft.Extensions.Options.DataAnnotations" Version="10.0.12" />
+    <PackageVersion Include="Microsoft.IdentityModel.JsonWebTokens" Version="8.23.0" />
+    <PackageVersion Include="Microsoft.OpenApi" Version="3.10.2" />
     <PackageVersion Include="MimeMapping" Version="4.0.0" />
-    <PackageVersion Include="Npgsql.EntityFrameworkCore.PostgreSQL" Version="10.0.2" />
-    <PackageVersion Include="OpenTelemetry" Version="1.15.3" />
-    <PackageVersion Include="OpenTelemetry.Api" Version="1.15.3" />
-    <PackageVersion Include="OpenTelemetry.Api.ProviderBuilderExtensions" Version="1.15.3" />
-    <PackageVersion Include="OpenTelemetry.Exporter.OpenTelemetryProtocol" Version="1.15.3" />
-    <PackageVersion Include="OpenTelemetry.Extensions.Hosting" Version="1.15.3" />
-    <PackageVersion Include="OpenTelemetry.Instrumentation.AspNetCore" Version="1.15.2" />
+    <PackageVersion Include="Npgsql.EntityFrameworkCore.PostgreSQL" Version="10.0.3" />
+    <PackageVersion Include="OpenTelemetry" Version="1.19.0" />
+    <PackageVersion Include="OpenTelemetry.Api" Version="1.19.0" />
+    <PackageVersion Include="OpenTelemetry.Api.ProviderBuilderExtensions" Version="1.19.0" />
+    <PackageVersion Include="OpenTelemetry.Exporter.OpenTelemetryProtocol" Version="1.19.0" />
+    <PackageVersion Include="OpenTelemetry.Extensions.Hosting" Version="1.19.0" />
+    <PackageVersion Include="OpenTelemetry.Instrumentation.AspNetCore" Version="1.19.0" />
     <PackageVersion Include="OpenTelemetry.Instrumentation.EntityFrameworkCore" Version="1.15.1-beta.1" />
-    <PackageVersion Include="OpenTelemetry.Instrumentation.Http" Version="1.15.1" />
+    <PackageVersion Include="OpenTelemetry.Instrumentation.Http" Version="1.19.0" />
     <PackageVersion Include="OpenTelemetry.Instrumentation.Process" Version="1.15.1-beta.1" />
-    <PackageVersion Include="OpenTelemetry.Instrumentation.Runtime" Version="1.15.1" />
-    <PackageVersion Include="Scalar.AspNetCore" Version="2.14.14" />
-    <PackageVersion Include="SixLabors.ImageSharp" Version="3.1.12" />
-    <PackageVersion Include="X.PagedList" Version="10.5.9" />
-    <PackageVersion Include="X.PagedList.EF" Version="10.5.9" />
+    <PackageVersion Include="OpenTelemetry.Instrumentation.Runtime" Version="1.19.0" />
+    <PackageVersion Include="Scalar.AspNetCore" Version="2.17.6" />
+    <PackageVersion Include="SixLabors.ImageSharp" Version="4.1.2" />
+    <PackageVersion Include="X.PagedList" Version="10.6.0" />
+    <PackageVersion Include="X.PagedList.EF" Version="10.6.0" />
     <PackageVersion Include="Yarp.ReverseProxy" Version="2.3.0" />
-
     <!-- Test-only -->
-    <PackageVersion Include="Microsoft.EntityFrameworkCore.Sqlite" Version="10.0.8" />
+    <PackageVersion Include="Microsoft.EntityFrameworkCore.Sqlite" Version="10.0.12" />
     <!-- Pins the native SQLite bundle EFCore.Sqlite pulls in transitively: 2.1.11 has
          a known high-severity advisory (GHSA-2m69-gcr7-jv3q), fixed in 2.1.13. -->
-    <PackageVersion Include="SQLitePCLRaw.bundle_e_sqlite3" Version="2.1.13" />
-    <PackageVersion Include="Microsoft.NET.Test.Sdk" Version="17.12.0" />
-    <PackageVersion Include="NSubstitute" Version="5.3.0" />
-    <PackageVersion Include="coverlet.collector" Version="6.0.4" />
-    <PackageVersion Include="xunit.v3" Version="4.0.0" />
+    <PackageVersion Include="SQLitePCLRaw.bundle_e_sqlite3" Version="3.0.5" />
+    <PackageVersion Include="Microsoft.NET.Test.Sdk" Version="18.10.1" />
+    <PackageVersion Include="NSubstitute" Version="6.2.0" />
+    <PackageVersion Include="coverlet.collector" Version="10.0.1" />
+    <PackageVersion Include="xunit.v3" Version="4.0.1" />
     <PackageVersion Include="xunit.runner.visualstudio" Version="4.0.0" />
-    <PackageVersion Include="Microsoft.AspNetCore.Mvc.Testing" Version="10.0.8" />
+    <PackageVersion Include="Microsoft.AspNetCore.Mvc.Testing" Version="10.0.12" />
     <PackageVersion Include="Testcontainers" Version="4.15.0" />
     <PackageVersion Include="Testcontainers.PostgreSql" Version="4.15.0" />
   </ItemGroup>
-
-</Project>
+</Project>

backend/Hosts/Musify.Api/Endpoints/UserEndpoints.cs

@@ -40,6 +40,12 @@ public static class UserEndpoints
             .WithSummary("Get A User'S Listening Stats For The Current Week And Streak.")
             .Produces<ListeningStatsResponse>();
 
+        group.MapGet("/{id}/last-listened-track", GetLastTrackListenedByUserId)
+            .WithName("GetLastTrackListenedByUserId")
+            .WithSummary("Get The Last Track A User Listened To.")
+            .Produces<TrackApplicationResponse>()
+            .Produces(StatusCodes.Status404NotFound);
+
         group.MapGet("/{id}/profile", GetUserProfile)
             .WithName("GetUserProfile")
             .WithSummary("Get A User'S Public Profile, Including Follower Counts.")
@@ -116,6 +122,15 @@ public static class UserEndpoints
         return await mediator.Send(new GetListeningStatsQuery(id), cancellationToken);
     }
 
+    private static async Task<IResult> GetLastTrackListenedByUserId(
+        IMediator mediator,
+        long id,
+        CancellationToken cancellationToken)
+    {
+        var result = await mediator.Send(new GetLastTrackListenedByUserIdQuery(id), cancellationToken);
+        return result.ToHttpResult();
+    }
+
     private static async Task<IResult> GetUserProfile(
         IMediator mediator,
         long id,

backend/Hosts/Musify.Worker/AppSettings.json

@@ -44,9 +44,7 @@
             "MediumPictureHeight": 256,
             "LargePictureWidth": 512,
             "LargePictureHeight": 512
-        },
-        "SeedPresetPictures": true,
-        "OverwritePresetPictures": false
+        }
     },
     "Track": {
         "Routes": {

backend/Hosts/Musify.Worker/Program.cs

@@ -30,7 +30,6 @@ services.AddStorageService(configuration);
 services.AddAudioTranscoder(configuration);
 services.AddHttpClient();
 services.AddPictureService(configuration);
-services.AddPlayListPresetSeeder(configuration);
 services.AddDatabase(configuration);
 services.AddMassTransitConsumers(configuration);
 services.AddUploadIntentJobs(configuration);

backend/Tests/Musify.Api.Tests/Endpoints/UserEndpointsTests.cs

@@ -1,8 +1,15 @@
 using System.Net;
 using System.Net.Http.Json;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.DependencyInjection;
 using Musify.Api.DataTransferObjects.Users;
 using Musify.Api.Tests.TestSupport;
+using Musify.Application.Tracks.Responses;
 using Musify.Application.Users.Responses;
+using Musify.Domain.Entities;
+using Musify.Infrastructure.Persistence;
 using Xunit;
 
 namespace Musify.Api.Tests.Endpoints
@@ -10,6 +17,33 @@ namespace Musify.Api.Tests.Endpoints
     [Collection(ApiCollection.Name)]
     public sealed class UserEndpointsTests(ApiTestFixture fixture)
     {
+        private static readonly JsonSerializerOptions JsonOptions = new(JsonSerializerDefaults.Web)
+        {
+            Converters = { new JsonStringEnumConverter() }
+        };
+
+        private async Task SeedListenAsync(long userId, string trackTitle, DateTime listenedAt)
+        {
+            using var scope = fixture.Services.CreateScope();
+            var database = scope.ServiceProvider.GetRequiredService<Database>();
+            var owner = await database.Users.SingleAsync(u => u.Id == userId);
+            var track = new Track
+            {
+                Title = trackTitle,
+                NormalizedTitle = trackTitle.ToUpperInvariant(),
+                OwnerUserId = owner.Id,
+                Owner = owner
+            };
+            database.Tracks.Add(track);
+            database.ListeningHistories.Add(new ListeningHistory
+            {
+                UserId = userId,
+                TrackId = track.Id,
+                ListenedAt = listenedAt
+            });
+            await database.SaveChangesAsync(TestContext.Current.CancellationToken);
+        }
+
         [Fact]
         public async Task PostUsers_NewUser_ReturnsCreatedWithLocationHeader()
         {
@@ -70,5 +104,33 @@ namespace Musify.Api.Tests.Endpoints
 
             Assert.Equal(HttpStatusCode.NotFound, response.StatusCode);
         }
+
+        [Fact]
+        public async Task GetLastTrackListenedByUserId_HasHistory_ReturnsMostRecentTrack()
+        {
+            var client = fixture.CreateAnonymousClient();
+            var userId = Random.Shared.NextInt64(1, long.MaxValue);
+            await client.PostAsJsonAsync("/users", new CreateUserRequest(userId, $"user-{userId}", null, null), TestContext.Current.CancellationToken);
+            await SeedListenAsync(userId, "Older listen", DateTime.UtcNow.AddMinutes(-10));
+            await SeedListenAsync(userId, "Newer listen", DateTime.UtcNow);
+
+            var response = await client.GetAsync($"/users/{userId}/last-listened-track", TestContext.Current.CancellationToken);
+
+            Assert.Equal(HttpStatusCode.OK, response.StatusCode);
+            var body = await response.Content.ReadFromJsonAsync<TrackApplicationResponse>(JsonOptions, TestContext.Current.CancellationToken);
+            Assert.Equal("Newer listen", body?.Title);
+        }
+
+        [Fact]
+        public async Task GetLastTrackListenedByUserId_NoHistory_ReturnsNotFound()
+        {
+            var client = fixture.CreateAnonymousClient();
+            var userId = Random.Shared.NextInt64(1, long.MaxValue);
+            await client.PostAsJsonAsync("/users", new CreateUserRequest(userId, $"user-{userId}", null, null), TestContext.Current.CancellationToken);
+
+            var response = await client.GetAsync($"/users/{userId}/last-listened-track", TestContext.Current.CancellationToken);
+
+            Assert.Equal(HttpStatusCode.NotFound, response.StatusCode);
+        }
     }
 }

backend/Tests/Musify.Api.Tests/TestSupport/ApiTestFixture.cs

@@ -78,7 +78,6 @@ namespace Musify.Api.Tests.TestSupport
                     ["InfrastructureStorage:UseHttp"] = "true",
                     ["ApplicationStorage:Bucket"] = "musify-api-test",
                     ["StreamGateway:PublicBaseUrl"] = "http://stream.musify.test",
-                    ["PlayList:SeedPresetPictures"] = "false",
                 });
             });
 

backend/Tests/Musify.Application.Tests/PlayLists/CreatePlayListCommandHandlerTests.cs

@@ -23,7 +23,7 @@ namespace Musify.Application.Tests.PlayLists
             TestConfigurations.UploadIntent());
 
         [Fact]
-        public async Task Handle_NoPictureIntent_CreatesPlayListWithPresetPictures()
+        public async Task Handle_NoPictureIntent_CreatesPlayListWithoutPictures()
         {
             var user = TestEntities.User();
             await SeedAsync(user);
@@ -34,7 +34,7 @@ namespace Musify.Application.Tests.PlayLists
 
             Assert.False(result.IsError);
             Assert.Equal("My Playlist", result.Value.Name);
-            Assert.Equal("PresetSmallPicture.webp", result.Value.SmallImageKeyName);
+            Assert.Null(result.Value.SmallImageKeyName);
             await eventBus.DidNotReceive().PublishAsync(Arg.Any<Musify.Application.Events.CreatePlayListResourcesEvent>(), Arg.Any<CancellationToken>());
         }
 

backend/Tests/Musify.Application.Tests/PlayLists/GetPlayListCoverQueryHandlerTests.cs

@@ -34,5 +34,18 @@ namespace Musify.Application.Tests.PlayLists
 
             Assert.Equal(ErrorType.NotFound, result.FirstError.Type);
         }
+
+        [Fact]
+        public async Task Handle_PlayListWithoutPictures_ReturnsNotFound()
+        {
+            var owner = TestEntities.User();
+            var playList = TestEntities.PlayList(owner.Id);
+            playList.Pictures = null;
+            await SeedAsync(owner, playList);
+
+            var result = await CreateHandler().Handle(new GetPlayListCoverQuery(playList.Id, "small"), TestContext.Current.CancellationToken);
+
+            Assert.Equal(ErrorType.NotFound, result.FirstError.Type);
+        }
     }
 }

backend/Tests/Musify.Application.Tests/TestSupport/TestDatabase.cs

@@ -45,8 +45,14 @@ namespace Musify.Application.Tests.TestSupport
                 .HasForeignKey(track => track.OwnerUserId)
                 .OnDelete(DeleteBehavior.Restrict);
 
-            modelBuilder.Entity<PlayList>().OwnsOne(playList => playList.Pictures);
-            modelBuilder.Entity<PlayList>().Navigation(playList => playList.Pictures).IsRequired();
+            modelBuilder.Entity<PlayList>().OwnsOne(playList => playList.Pictures, pictures =>
+            {
+                pictures.Property(p => p.OriginalName).IsRequired(false);
+                pictures.Property(p => p.SmallName).IsRequired(false);
+                pictures.Property(p => p.MediumName).IsRequired(false);
+                pictures.Property(p => p.LargeName).IsRequired(false);
+            });
+            modelBuilder.Entity<PlayList>().Navigation(playList => playList.Pictures).IsRequired(false);
 
             modelBuilder.Entity<Album>().OwnsOne(album => album.Pictures);
             modelBuilder.Entity<Album>().Navigation(album => album.Pictures).IsRequired(false);

backend/Tests/Musify.Application.Tests/Tracks/GetLastTrackListenedByUserIdQueryHandlerTests.cs

@@ -0,0 +1,40 @@
+using ErrorOr;
+using Musify.Application.Tests.TestSupport;
+using Musify.Application.Tracks;
+using Xunit;
+
+namespace Musify.Application.Tests.Tracks
+{
+    public sealed class GetLastTrackListenedByUserIdQueryHandlerTests : HandlerTestBase
+    {
+        private GetLastTrackListenedByUserIdQueryHandler CreateHandler() => new(Database);
+
+        [Fact]
+        public async Task Handle_MultipleListens_ReturnsMostRecentlyListenedTrack()
+        {
+            var owner = TestEntities.User();
+            var older = TestEntities.Track(owner, "Older listen");
+            var newer = TestEntities.Track(owner, "Newer listen");
+            await SeedAsync(
+                owner, older, newer,
+                TestEntities.ListeningHistory(owner.Id, older.Id, DateTime.UtcNow.AddMinutes(-10)),
+                TestEntities.ListeningHistory(owner.Id, newer.Id, DateTime.UtcNow));
+
+            var result = await CreateHandler().Handle(new GetLastTrackListenedByUserIdQuery(owner.Id), TestContext.Current.CancellationToken);
+
+            Assert.False(result.IsError);
+            Assert.Equal("Newer listen", result.Value.Title);
+        }
+
+        [Fact]
+        public async Task Handle_NoHistory_ReturnsNotFound()
+        {
+            var owner = TestEntities.User();
+            await SeedAsync(owner);
+
+            var result = await CreateHandler().Handle(new GetLastTrackListenedByUserIdQuery(owner.Id), TestContext.Current.CancellationToken);
+
+            Assert.Equal(ErrorType.NotFound, result.FirstError.Type);
+        }
+    }
+}

backend/Tests/Musify.Infrastructure.Tests/Services/PlayListPresetSeederTests.cs

@@ -1,103 +0,0 @@
-using Microsoft.Extensions.DependencyInjection;
-using Microsoft.Extensions.Logging.Abstractions;
-using Musify.Application.Configuration;
-using Musify.Application.Contracts;
-using Musify.Infrastructure.Configuration;
-using Musify.Infrastructure.Services;
-using Musify.Infrastructure.Tests.TestSupport;
-using Xunit;
-
-namespace Musify.Infrastructure.Tests.Services
-{
-    [Collection(InfrastructureCollection.Name)]
-    public sealed class PlayListPresetSeederTests(InfrastructureTestFixture fixture)
-    {
-        private static PlayListConfiguration NewConfiguration(bool overwritePresetPictures) => new()
-        {
-            Routes = new PlayListRoutes { ParentFolders = $"PlayLists-{Guid.NewGuid():N}" },
-            SeedPresetPictures = true,
-            OverwritePresetPictures = overwritePresetPictures
-        };
-
-        private (PlayListPresetSeeder Seeder, IStorageService Storage) Build(PlayListConfiguration configuration)
-        {
-            var services = new ServiceCollection();
-            services.AddSingleton(configuration);
-            services.AddSingleton(new ApplicationStorageConfiguration { Bucket = InfrastructureTestFixture.S3Bucket });
-            services.AddSingleton<IStorageService>(_ => new StorageService(
-                fixture.CreateDatabase(),
-                fixture.CreateS3Client(),
-                NullLogger<StorageService>.Instance,
-                new InfrastructureStorageConfiguration
-                {
-                    Address = fixture.S3ServiceUrl,
-                    AccessKey = InfrastructureTestFixture.S3AccessKey,
-                    SecretAccessKey = InfrastructureTestFixture.S3SecretKey,
-                    ForcePathStyle = true,
-                    UseHttp = true,
-                }));
-            services.AddSingleton<IPictureService>(new PictureService(NullLogger<PictureService>.Instance));
-
-            var provider = services.BuildServiceProvider();
-            var seeder = new PlayListPresetSeeder(provider.GetRequiredService<IServiceScopeFactory>(), NullLogger<PlayListPresetSeeder>.Instance);
-            return (seeder, provider.GetRequiredService<IStorageService>());
-        }
-
-        private static async Task RunToCompletionAsync(PlayListPresetSeeder seeder)
-        {
-            await seeder.StartAsync(TestContext.Current.CancellationToken);
-            await (seeder.ExecuteTask ?? Task.CompletedTask);
-        }
-
-        [Fact]
-        public async Task ExecuteAsync_SeedsAllFourPresetPictures()
-        {
-            var configuration = NewConfiguration(overwritePresetPictures: false);
-            var (seeder, storage) = Build(configuration);
-
-            await RunToCompletionAsync(seeder);
-
-            var routes = configuration.Routes;
-            foreach (var key in new[]
-                     {
-                         routes.BuildOriginalPicturePath(routes.PresetOriginalPicture),
-                         routes.PresetSmallPicturePath,
-                         routes.PresetMediumPicturePath,
-                         routes.PresetLargePicturePath
-                     })
-            {
-                var metadata = await storage.HeadObjectAsync(InfrastructureTestFixture.S3Bucket, key, TestContext.Current.CancellationToken);
-                Assert.True(metadata is not null, $"expected {key} to have been seeded");
-            }
-        }
-
-        [Fact]
-        public async Task ExecuteAsync_RunTwiceWithoutOverwrite_StaysIdempotent()
-        {
-            var configuration = NewConfiguration(overwritePresetPictures: false);
-            var (firstSeeder, storage) = Build(configuration);
-            await RunToCompletionAsync(firstSeeder);
-
-            var (secondSeeder, _) = Build(configuration);
-            await RunToCompletionAsync(secondSeeder);
-
-            var metadata = await storage.HeadObjectAsync(
-                InfrastructureTestFixture.S3Bucket, configuration.Routes.PresetSmallPicturePath, TestContext.Current.CancellationToken);
-            Assert.NotNull(metadata);
-        }
-
-        [Fact]
-        public async Task ExecuteAsync_SeedPresetPicturesDisabled_UploadsNothing()
-        {
-            var configuration = NewConfiguration(overwritePresetPictures: false);
-            configuration.SeedPresetPictures = false;
-            var (seeder, storage) = Build(configuration);
-
-            await RunToCompletionAsync(seeder);
-
-            var metadata = await storage.HeadObjectAsync(
-                InfrastructureTestFixture.S3Bucket, configuration.Routes.PresetSmallPicturePath, TestContext.Current.CancellationToken);
-            Assert.Null(metadata);
-        }
-    }
-}