Merge branch 'backend-refactor-rev' into audit-merge-three

Adapt the refactored web player to the new backend API (id path params,
bulk track adds, flat list items, mix kind) and port AddAlbumToPlayList
to the backend conventions.

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

@@ -2,12 +2,15 @@ using ErrorOr;
 using Mediator;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.Logging;
+using Musify.Application.Albums.Responses;
 using Musify.Application.Contracts;
 using Musify.Application.PlayLists.Responses;
+using Musify.Application.Shared;
 using Musify.Domain.Entities;
 
 namespace Musify.Application.PlayLists
 {
+    /// <summary>Appends every track of an album to a playlist in album order, skipping the ones it already has.</summary>
     public record AddAlbumToPlayListCommand(long UserId, Guid PlayListId, Guid AlbumId)
         : ICommand<ErrorOr<AddAlbumToPlayListResponse>>;
 
@@ -18,41 +21,29 @@ namespace Musify.Application.PlayLists
     {
         public async ValueTask<ErrorOr<AddAlbumToPlayListResponse>> Handle(AddAlbumToPlayListCommand request, CancellationToken cancellationToken)
         {
-            var playList = await database.PlayLists
-                .SingleOrDefaultAsync(pl => pl.Id == request.PlayListId, cancellationToken);
-            if (playList == null)
-            {
-                logger.LogInformation("Playlist {PlayListId} not found", request.PlayListId);
-                return Error.NotFound();
-            }
-
-            if (playList.UserId != request.UserId)
-            {
-                logger.LogWarning("User {UserId} is not the owner of playlist {PlayListId}", request.UserId, request.PlayListId);
-                return Error.Unauthorized();
-            }
+            var playList = await database.PlayLists.FindOwnedAsync(request.PlayListId, request.UserId, cancellationToken);
+            if (playList.IsError)
+                return playList.Errors;
 
             var albumExists = await database.Albums
                 .AsNoTracking()
+                .Active()
                 .AnyAsync(album => album.Id == request.AlbumId, cancellationToken);
             if (!albumExists)
-            {
-                logger.LogInformation("Album {AlbumId} not found", request.AlbumId);
-                return Error.NotFound(description: $"Album {request.AlbumId} not found");
-            }
+                return AppErrors.NotFound("Album", request.AlbumId);
 
             var albumTrackIds = await database.AlbumHasTracks
                 .AsNoTracking()
-                .Where(albumTrack => albumTrack.AlbumId == request.AlbumId)
+                .Where(albumTrack => albumTrack.AlbumId == request.AlbumId && albumTrack.Track.LifeCycleStatus == Domain.ValueObjects.LifeCycleStatus.Active)
                 .OrderBy(albumTrack => albumTrack.TrackNumber)
                 .Select(albumTrack => albumTrack.TrackId)
                 .ToListAsync(cancellationToken);
 
             var playListTracksQuery = database.PlayListHasTracks
-                .Where(plt => plt.PlayListId == request.PlayListId);
+                .Where(link => link.PlayListId == request.PlayListId);
 
             var existingTrackIds = (await playListTracksQuery
-                .Select(plt => plt.TrackId)
+                .Select(link => link.TrackId)
                 .ToListAsync(cancellationToken)).ToHashSet();
 
             var newTrackIds = albumTrackIds
@@ -62,20 +53,24 @@ namespace Musify.Application.PlayLists
             if (newTrackIds.Count == 0)
                 return new AddAlbumToPlayListResponse(0);
 
-            var nextPosition = existingTrackIds.Count > 0
-                ? await playListTracksQuery.MaxAsync(plt => plt.Position, cancellationToken) + 1
-                : 0;
+            // Playlist positions are internal indexes, so they start at 0.
+            var nextPosition = (await playListTracksQuery
+                .MaxAsync(link => (int?)link.Position, cancellationToken) ?? -1) + 1;
 
-            await database.PlayListHasTracks.AddRangeAsync(
-                newTrackIds.Select((trackId, index) => new PlayListHasTrack
+            foreach (var trackId in newTrackIds)
+            {
+                await database.PlayListHasTracks.AddAsync(new PlayListHasTrack
                 {
                     PlayListId = request.PlayListId,
                     TrackId = trackId,
-                    Position = nextPosition + index
-                }),
-                cancellationToken);
+                    Position = nextPosition++
+                }, cancellationToken);
+            }
 
-            await database.SaveChangesAsync(cancellationToken);
+            var saved = await database.TrySaveChangesAsync(
+                AppErrors.Conflict("PlayList.ConcurrentChange", "The playlist changed while adding tracks. Try again."), cancellationToken);
+            if (saved.IsError)
+                return saved.Errors;
 
             logger.LogInformation("Added {Count} tracks from album {AlbumId} to playlist {PlayListId}",
                 newTrackIds.Count, request.AlbumId, request.PlayListId);

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

@@ -1,75 +0,0 @@
-using ErrorOr;
-using Mediator;
-using Microsoft.EntityFrameworkCore;
-using Microsoft.Extensions.Logging;
-using Musify.Application.Contracts;
-using Musify.Domain.Entities;
-
-namespace Musify.Application.PlayLists
-{
-    public record AddTrackToPlayListCommand(long UserId, Guid PlayListId, Guid TrackId)
-        : ICommand<ErrorOr<Success>>;
-
-    public class AddTrackToPlayListCommandHandler(
-        IDatabase database,
-        ILogger<AddTrackToPlayListCommandHandler> logger)
-        : ICommandHandler<AddTrackToPlayListCommand, ErrorOr<Success>>
-    {
-        public async ValueTask<ErrorOr<Success>> Handle(AddTrackToPlayListCommand request, CancellationToken cancellationToken)
-        {
-            var playList = await database.PlayLists
-                .SingleOrDefaultAsync(pl => pl.Id == request.PlayListId, cancellationToken);
-            if (playList == null)
-            {
-                logger.LogInformation("Playlist {PlayListId} not found", request.PlayListId);
-                return Error.NotFound();
-            }
-
-            if (playList.UserId != request.UserId)
-            {
-                logger.LogWarning("User {UserId} is not the owner of playlist {PlayListId}", request.UserId, request.PlayListId);
-                return Error.Unauthorized();
-            }
-
-            var trackExists = await database.Tracks
-                .AsNoTracking()
-                .AnyAsync(t => t.Id == request.TrackId, cancellationToken);
-            if (!trackExists)
-            {
-                logger.LogInformation("Track {TrackId} not found", request.TrackId);
-                return Error.NotFound(description: $"Track {request.TrackId} not found");
-            }
-
-            var alreadyAdded = await database.PlayListHasTracks
-                .AsNoTracking()
-                .AnyAsync(plt => plt.PlayListId == request.PlayListId && plt.TrackId == request.TrackId, cancellationToken);
-            if (alreadyAdded)
-            {
-                logger.LogInformation("Track {TrackId} already in playlist {PlayListId}", request.TrackId, request.PlayListId);
-                return Error.Conflict(description: "Track is already in the playlist.");
-            }
-
-            var playListTracksQuery = database.PlayListHasTracks
-                .Where(plt => plt.PlayListId == request.PlayListId);
-
-            var hasTracks = await playListTracksQuery.AnyAsync(cancellationToken);
-            var nextPosition = hasTracks
-                ? await playListTracksQuery.MaxAsync(plt => plt.Position, cancellationToken) + 1
-                : 0;
-
-            await database.PlayListHasTracks.AddAsync(new PlayListHasTrack
-            {
-                PlayListId = request.PlayListId,
-                TrackId = request.TrackId,
-                Position = nextPosition
-            }, cancellationToken);
-
-            await database.SaveChangesAsync(cancellationToken);
-
-            logger.LogInformation("Added track {TrackId} to playlist {PlayListId} at position {Position}",
-                request.TrackId, request.PlayListId, nextPosition);
-
-            return new Success();
-        }
-    }
-}

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

@@ -0,0 +1,74 @@
+using ErrorOr;
+using Mediator;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Logging;
+using Musify.Application.Contracts;
+using Musify.Application.Shared;
+using Musify.Domain.Entities;
+using Musify.Domain.ValueObjects;
+
+namespace Musify.Application.PlayLists
+{
+    /// <summary>Appends tracks to a playlist in the given order, skipping the ones it already has.</summary>
+    public record AddTracksToPlayListCommand(long UserId, Guid PlayListId, IReadOnlyList<Guid> TrackIds)
+        : ICommand<ErrorOr<Success>>;
+
+    public class AddTracksToPlayListCommandHandler(
+        IDatabase database,
+        ILogger<AddTracksToPlayListCommandHandler> logger)
+        : ICommandHandler<AddTracksToPlayListCommand, ErrorOr<Success>>
+    {
+        public async ValueTask<ErrorOr<Success>> Handle(AddTracksToPlayListCommand request, CancellationToken cancellationToken)
+        {
+            var playList = await database.PlayLists.FindOwnedAsync(request.PlayListId, request.UserId, cancellationToken);
+            if (playList.IsError)
+                return playList.Errors;
+
+            var requestedIds = request.TrackIds.Distinct().ToList();
+
+            var existingIds = await database.Tracks
+                .AsNoTracking()
+                .Where(track => requestedIds.Contains(track.Id) && track.LifeCycleStatus == LifeCycleStatus.Active)
+                .Select(track => track.Id)
+                .ToListAsync(cancellationToken);
+
+            var missing = requestedIds.FirstOrDefault(id => !existingIds.Contains(id));
+            if (missing != Guid.Empty)
+                return AppErrors.NotFound("Track", missing);
+
+            var alreadyInPlayList = await database.PlayListHasTracks
+                .AsNoTracking()
+                .Where(link => link.PlayListId == request.PlayListId && requestedIds.Contains(link.TrackId))
+                .Select(link => link.TrackId)
+                .ToListAsync(cancellationToken);
+
+            var toAdd = requestedIds.Where(id => !alreadyInPlayList.Contains(id)).ToList();
+            if (toAdd.Count == 0)
+                return Result.Success;
+
+            // Playlist positions are internal indexes, so they start at 0.
+            var nextPosition = (await database.PlayListHasTracks
+                .Where(link => link.PlayListId == request.PlayListId)
+                .MaxAsync(link => (int?)link.Position, cancellationToken) ?? -1) + 1;
+
+            foreach (var trackId in toAdd)
+            {
+                await database.PlayListHasTracks.AddAsync(new PlayListHasTrack
+                {
+                    PlayListId = request.PlayListId,
+                    TrackId = trackId,
+                    Position = nextPosition++
+                }, cancellationToken);
+            }
+
+            var saved = await database.TrySaveChangesAsync(
+                AppErrors.Conflict("PlayList.ConcurrentChange", "The playlist changed while adding tracks. Try again."), cancellationToken);
+            if (saved.IsError)
+                return saved;
+
+            logger.LogInformation("Added {Count} tracks to playlist {PlayListId}", toAdd.Count, request.PlayListId);
+
+            return Result.Success;
+        }
+    }
+}

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

@@ -3,13 +3,14 @@ using Mediator;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.Logging;
 using Musify.Application.Configuration;
-using Musify.Application.Shared;
+using Musify.Application.Contracts;
 using Musify.Application.Events;
+using Musify.Application.Pictures;
 using Musify.Application.PlayLists.Responses;
 using Musify.Application.Services;
+using Musify.Application.Shared;
 using Musify.Domain.Entities;
 using Musify.Domain.ValueObjects;
-using Musify.Application.Contracts;
 
 namespace Musify.Application.PlayLists
 {
@@ -18,7 +19,7 @@ namespace Musify.Application.PlayLists
         string Name,
         string? Description,
         Guid? PictureIntentId,
-        PlaylistVisibility Visibility = PlaylistVisibility.Private)
+        PlayListVisibility Visibility = PlayListVisibility.Private)
         : ICommand<ErrorOr<PlayListApplicationResponse>>;
 
     public class CreatePlayListCommandHandler(
@@ -26,121 +27,53 @@ namespace Musify.Application.PlayLists
         IDatabase database,
         UploadIntentValidator uploadIntentValidator,
         ILogger<CreatePlayListCommandHandler> logger,
-        ApplicationStorageConfiguration storageConfiguration,
-        PlayListConfiguration playListConfiguration,
-        UploadIntentConfiguration uploadIntentConfiguration)
+        PlayListConfiguration playListConfiguration)
         : ICommandHandler<CreatePlayListCommand, ErrorOr<PlayListApplicationResponse>>
     {
-        private sealed record ResolvedPlayListPictures(PlayListPictures? Pictures, UploadIntent? Intent);
-
         public async ValueTask<ErrorOr<PlayListApplicationResponse>> Handle(CreatePlayListCommand request, CancellationToken cancellationToken)
         {
             var userExists = await database.Users
                 .AsNoTracking()
                 .AnyAsync(u => u.Id == request.UserId, cancellationToken);
             if (!userExists)
+                return AppErrors.NotFound("User", request.UserId);
+
+            PreparedPicture? picture = null;
+            if (request.PictureIntentId is { } intentId)
             {
-                logger.LogWarning("User {UserId} not found", request.UserId);
-                return Error.NotFound(description: $"User {request.UserId} not found");
+                var prepared = await PictureSourceChange.PrepareAsync(
+                    uploadIntentValidator, intentId, request.UserId, UploadIntentPurpose.PlayListPicture, playListConfiguration, cancellationToken);
+                if (prepared.IsError)
+                    return prepared.Errors;
+
+                picture = prepared.Value;
             }
 
-            var picturesResult = await ResolvePicturesAsync(request, cancellationToken);
-            if (picturesResult.IsError)
-                return picturesResult.Errors;
-
-            var resolvedPictures = picturesResult.Value;
-
+            var name = request.Name.Trim();
             var playList = new PlayList
             {
-                UserId = request.UserId,
-                Name = request.Name,
-                NormalizedName = request.Name.Trim().ToUpperInvariant(),
+                OwnerUserId = request.UserId,
+                Name = name,
+                NormalizedName = TextNormalizer.Normalize(name),
                 Description = string.IsNullOrWhiteSpace(request.Description) ? null : request.Description.Trim(),
-                Pictures = resolvedPictures.Pictures,
+                Pictures = picture?.Pictures,
                 Visibility = request.Visibility
             };
             await database.PlayLists.AddAsync(playList, cancellationToken);
 
-            if (resolvedPictures.Intent != null)
-            {
-                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;
-            }
-
-            try
-            {
-                await database.SaveChangesAsync(cancellationToken);
-            }
-            catch (Exception exception)
-            {
-                logger.LogError(exception, "Failed to save playlist for user {UserId}", request.UserId);
-                return Error.Failure(description: $"Failed to create playlist for user {request.UserId}");
-            }
-
-            logger.LogInformation("Created playlist {PlayListId} for user {UserId}", playList.Id, request.UserId);
-            return PlayListApplicationResponse.FromEntity(playList);
-        }
-
-        private async ValueTask<ErrorOr<ResolvedPlayListPictures>> ResolvePicturesAsync(
-            CreatePlayListCommand request, CancellationToken cancellationToken)
-        {
-            if (!request.PictureIntentId.HasValue)
-            {
-                return new ResolvedPlayListPictures(null, null);
-            }
-
-            var validation = await uploadIntentValidator.ValidateAndLoadAsync(
-                uploadIntentConfiguration, request.PictureIntentId.Value, request.UserId, cancellationToken);
-
-            if (validation.IsError)
-                return validation.Errors;
-
-            return new ResolvedPlayListPictures(new PlayListPictures
-            {
-                OriginalName = validation.Value.ObjectName,
-                SmallName = validation.Value.ObjectName,
-                MediumName = validation.Value.ObjectName,
-                LargeName = validation.Value.ObjectName
-            }, validation.Value);
-        }
-
-        private async Task<ErrorOr<Success>> PublishCreatePlayListEventAsync(
-            Guid playListId,
-            UploadIntent pictureIntent,
-            string finalPictureKey,
-            CancellationToken cancellationToken)
-        {
-            try
+            if (picture != null)
             {
                 await eventBus.PublishAsync(
                     new CreatePlayListResourcesEvent(
-                        playListId,
-                        pictureIntent.Id,
-                        storageConfiguration.Bucket,
-                        pictureIntent.Key,
-                        finalPictureKey,
-                        new ImageSize(
-                            playListConfiguration.Routes.SmallPicturesPath,
-                            playListConfiguration.PicturesSizes.SmallPictureWidth,
-                            playListConfiguration.PicturesSizes.SmallPictureHeight),
-                        new ImageSize(
-                            playListConfiguration.Routes.MediumPicturesPath,
-                            playListConfiguration.PicturesSizes.MediumPictureWidth,
-                            playListConfiguration.PicturesSizes.MediumPictureHeight),
-                        new ImageSize(
-                            playListConfiguration.Routes.LargePicturesPath,
-                            playListConfiguration.PicturesSizes.LargePictureWidth,
-                            playListConfiguration.PicturesSizes.LargePictureHeight)),
+                        playList.Id, picture.Intent.Id, picture.Intent.Bucket, picture.Intent.Key, picture.FinalKey, picture.Sizes),
                     cancellationToken);
-                return new Success();
-            }
-            catch (Exception exception)
-            {
-                logger.LogError(exception, "Failed to publish create playlist event for playlist {PlayListId}", playListId);
-                return Error.Failure(description: $"Failed to publish create playlist event for playlist {playListId}");
             }
+
+            await database.SaveChangesAsync(cancellationToken);
+
+            logger.LogInformation("Created playlist {PlayListId} for user {UserId}", playList.Id, request.UserId);
+
+            return PlayListApplicationResponse.FromEntity(playList);
         }
     }
 }

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

@@ -1,9 +1,9 @@
 using ErrorOr;
 using Mediator;
-using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.Logging;
 using Musify.Application.Contracts;
 using Musify.Application.Events;
+using Musify.Application.Shared;
 using Musify.Domain.ValueObjects;
 
 namespace Musify.Application.PlayLists
@@ -19,44 +19,19 @@ namespace Musify.Application.PlayLists
     {
         public async ValueTask<ErrorOr<Success>> Handle(DeletePlayListCommand request, CancellationToken cancellationToken)
         {
-            var playList = await database.PlayLists.SingleOrDefaultAsync(p => p.Id == request.PlayListId, cancellationToken);
-            if (playList == null)
-            {
-                logger.LogDebug("Playlist {PlayListId} not found", request.PlayListId);
-                return Error.NotFound();
-            }
-
-            if (playList.UserId != request.UserId)
-            {
-                logger.LogWarning("Playlist {PlayListId} does not belong to user {UserId}", request.PlayListId, request.UserId);
-                return Error.Unauthorized();
-            }
+            var found = await database.PlayLists.FindOwnedAsync(request.PlayListId, request.UserId, cancellationToken);
+            if (found.IsError)
+                return found.Errors;
 
+            var playList = found.Value;
             playList.LifeCycleStatus = LifeCycleStatus.Removing;
 
-            try
-            {
-                await eventBus.PublishAsync(
-                    new DeletePlayListEvent(playList.Id, request.UserId),
-                    cancellationToken);
-            }
-            catch (Exception exception)
-            {
-                logger.LogError(exception, "Failed to publish delete playlist event for playlist {PlayListId}", request.PlayListId);
-                return Error.Failure(description: $"Failed to delete playlist {request.PlayListId}");
-            }
+            await eventBus.PublishAsync(new DeletePlayListEvent(playList.Id, request.UserId), cancellationToken);
+            await database.SaveChangesAsync(cancellationToken);
 
-            try
-            {
-                await database.SaveChangesAsync(cancellationToken);
-            }
-            catch (Exception exception)
-            {
-                logger.LogError(exception, "Failed to mark playlist {PlayListId} as removing", request.PlayListId);
-                return Error.Failure(description: $"Failed to delete playlist {request.PlayListId}");
-            }
+            logger.LogInformation("Marked playlist {PlayListId} as removing", request.PlayListId);
 
-            return new Success();
+            return Result.Success;
         }
     }
 }

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

@@ -1,9 +1,9 @@
 using ErrorOr;
-using Microsoft.EntityFrameworkCore;
-using Musify.Application.PlayLists.Responses;
 using Mediator;
+using Microsoft.EntityFrameworkCore;
 using Musify.Application.Contracts;
-using Musify.Domain.ValueObjects;
+using Musify.Application.PlayLists.Responses;
+using Musify.Application.Shared;
 
 namespace Musify.Application.PlayLists
 {
@@ -15,30 +15,17 @@ namespace Musify.Application.PlayLists
     {
         public async ValueTask<ErrorOr<PlayListApplicationResponse>> Handle(GetPlayListByIdQuery request, CancellationToken cancellationToken)
         {
-            var entry = await database.PlayLists
+            var playList = await database.PlayLists
                 .AsNoTracking()
+                .Active()
+                .VisibleTo(request.RequestingUserId)
                 .Where(p => p.Id == request.Id)
-                .Select(p => new
-                {
-                    PlayList = p,
-                    TrackCount = p.PlayListTracks.Count,
-                    DurationSeconds = p.PlayListTracks.Sum(plt => (double?)plt.Track.DurationSeconds) ?? 0,
-                    CoverTrackIds = p.PlayListTracks
-                        .OrderBy(plt => plt.Position)
-                        .Take(PlayListApplicationResponse.CoverTrackCount)
-                        .Select(plt => plt.TrackId)
-                        .ToList()
-                })
+                .SelectResponse()
                 .SingleOrDefaultAsync(cancellationToken);
 
-            if (entry == null)
-                return Error.NotFound();
-
-            if (entry.PlayList.Visibility == PlaylistVisibility.Private
-                && entry.PlayList.UserId != request.RequestingUserId)
-                return Error.NotFound();
-
-            return PlayListApplicationResponse.FromEntity(entry.PlayList, entry.TrackCount, entry.DurationSeconds, entry.CoverTrackIds);
+            return playList == null
+                ? AppErrors.NotFound("PlayList", request.Id)
+                : playList;
         }
     }
 }

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

@@ -1,49 +0,0 @@
-using ErrorOr;
-using Mediator;
-using Microsoft.EntityFrameworkCore;
-using MimeMapping;
-using Musify.Application.Configuration;
-using Musify.Application.Contracts;
-
-namespace Musify.Application.PlayLists
-{
-    public record GetPlayListCoverQuery(Guid PlayListId, string Size)
-        : IQuery<ErrorOr<PlayListCoverLocation>>;
-
-    public record PlayListCoverLocation(string Bucket, string Key, string ContentType);
-
-    public class GetPlayListCoverQueryHandler(
-        IDatabase database,
-        ApplicationStorageConfiguration storageConfiguration,
-        PlayListConfiguration playListConfiguration)
-        : IQueryHandler<GetPlayListCoverQuery, ErrorOr<PlayListCoverLocation>>
-    {
-        public async ValueTask<ErrorOr<PlayListCoverLocation>> Handle(GetPlayListCoverQuery request, CancellationToken cancellationToken)
-        {
-            var pictures = await database.PlayLists.AsNoTracking()
-                .Where(p => p.Id == request.PlayListId)
-                .Select(p => p.Pictures)
-                .SingleOrDefaultAsync(cancellationToken);
-
-            if (pictures == null)
-                return Error.NotFound();
-
-            var routes = playListConfiguration.Routes;
-            var (name, key) = request.Size.ToLowerInvariant() switch
-            {
-                "small" => (pictures.SmallName, BuildKey(routes.BuildSmallPicturePath, pictures.SmallName)),
-                "large" => (pictures.LargeName, BuildKey(routes.BuildLargePicturePath, pictures.LargeName)),
-                _ => (pictures.MediumName, BuildKey(routes.BuildMediumPicturePath, pictures.MediumName))
-            };
-
-            if (string.IsNullOrEmpty(name) || string.IsNullOrEmpty(key))
-                return Error.NotFound();
-
-            var contentType = MimeUtility.GetMimeMapping(name);
-            return new PlayListCoverLocation(storageConfiguration.Bucket, key, contentType);
-        }
-
-        private static string? BuildKey(Func<string, string> builder, string? name)
-            => string.IsNullOrEmpty(name) ? null : builder(name);
-    }
-}

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

@@ -2,17 +2,18 @@ using ErrorOr;
 using Mediator;
 using Microsoft.EntityFrameworkCore;
 using Musify.Application.Contracts;
+using Musify.Application.PlayLists.Responses;
 using Musify.Application.Shared;
 using Musify.Application.Tracks.Responses;
-using X.PagedList;
-using X.PagedList.EF;
+using Musify.Domain.ValueObjects;
 
 namespace Musify.Application.PlayLists
 {
     public record GetPlayListTracksQuery(
         Guid PlayListId,
         int PageNumber,
-        int PageSize)
+        int PageSize,
+        long? ViewerId = null)
         : IQuery<ErrorOr<PaginatedResponse<TrackApplicationResponse>>>;
 
     public class GetPlayListTracksQueryHandler(IDatabase database)
@@ -20,30 +21,22 @@ namespace Musify.Application.PlayLists
     {
         public async ValueTask<ErrorOr<PaginatedResponse<TrackApplicationResponse>>> Handle(GetPlayListTracksQuery request, CancellationToken cancellationToken)
         {
-            var playListExists = await database.PlayLists
+            var playListVisible = await database.PlayLists
                 .AsNoTracking()
-                .AnyAsync(p => p.Id == request.PlayListId, cancellationToken);
-            if (!playListExists)
-                return Error.NotFound();
+                .Active()
+                .VisibleTo(request.ViewerId)
+                .AnyAsync(playList => playList.Id == request.PlayListId, cancellationToken);
+            if (!playListVisible)
+                return AppErrors.NotFound("PlayList", request.PlayListId);
 
-            var tracksQuery = database.PlayListHasTracks
+            return await database.PlayListHasTracks
                 .AsNoTracking()
-                .Include(plt => plt.Track.Owner)
-                .Include(plt => plt.Track.Tags)
-                .Where(plt => plt.PlayListId == request.PlayListId);
-
-            var totalCount = await tracksQuery.CountAsync(cancellationToken);
-
-            var pagedEntities = await tracksQuery
-                .OrderBy(plt => plt.Position)
-                .Select(plt => new { plt.Track, ListensCount = plt.Track.ListeningHistories.Count(l => l.IsCounted) })
-                .ToPagedListAsync(request.PageNumber, request.PageSize, totalCount, cancellationToken);
-
-            var pagedTracks = new StaticPagedList<TrackApplicationResponse>(
-                pagedEntities.Select(x => TrackApplicationResponse.FromEntity(x.Track, x.ListensCount)),
-                pagedEntities.PageNumber, pagedEntities.PageSize, pagedEntities.TotalItemCount);
-
-            return PaginatedResponse<TrackApplicationResponse>.FromPagedList(pagedTracks);
+                .Where(playListTrack => playListTrack.PlayListId == request.PlayListId && playListTrack.Track.LifeCycleStatus == LifeCycleStatus.Active)
+                .OrderBy(playListTrack => playListTrack.Position)
+                .ThenBy(playListTrack => playListTrack.Id)
+                .Select(playListTrack => playListTrack.Track)
+                .SelectResponse()
+                .ToPaginatedAsync(new PageRequest(request.PageNumber, request.PageSize), cancellationToken);
         }
     }
 }

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

@@ -1,45 +0,0 @@
-using ErrorOr;
-using Microsoft.EntityFrameworkCore;
-using Musify.Application.Shared;
-using Musify.Application.PlayLists.Responses;
-using X.PagedList;
-using X.PagedList.EF;
-using Mediator;
-using Musify.Application.Contracts;
-
-namespace Musify.Application.PlayLists
-{
-    public record GetPlayListsQuery(int PageNumber, int PageSize)
-        : IQuery<ErrorOr<PaginatedResponse<PlayListApplicationResponse>>>;
-
-    public class GetPlayListsQueryHandler(IDatabase database)
-        : IQueryHandler<GetPlayListsQuery, ErrorOr<PaginatedResponse<PlayListApplicationResponse>>>
-    {
-        public async ValueTask<ErrorOr<PaginatedResponse<PlayListApplicationResponse>>> Handle(GetPlayListsQuery request, CancellationToken cancellationToken)
-        {
-            var totalCount = await database.PlayLists.CountAsync(cancellationToken);
-
-            var pagedEntities = await database.PlayLists
-                .AsNoTracking()
-                .OrderBy(p => p.Id)
-                .Select(p => new
-                {
-                    PlayList = p,
-                    TrackCount = p.PlayListTracks.Count,
-                    DurationSeconds = p.PlayListTracks.Sum(plt => (double?)plt.Track.DurationSeconds) ?? 0,
-                    CoverTrackIds = p.PlayListTracks
-                        .OrderBy(plt => plt.Position)
-                        .Take(PlayListApplicationResponse.CoverTrackCount)
-                        .Select(plt => plt.TrackId)
-                        .ToList()
-                })
-                .ToPagedListAsync(request.PageNumber, request.PageSize, totalCount, cancellationToken);
-
-            var pagedPlayLists = new StaticPagedList<PlayListApplicationResponse>(
-                pagedEntities.Select(entry => PlayListApplicationResponse.FromEntity(entry.PlayList, entry.TrackCount, entry.DurationSeconds, entry.CoverTrackIds)),
-                pagedEntities.PageNumber, pagedEntities.PageSize, pagedEntities.TotalItemCount);
-
-            return PaginatedResponse<PlayListApplicationResponse>.FromPagedList(pagedPlayLists);
-        }
-    }
-}

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

@@ -1,12 +1,8 @@
-using ErrorOr;
 using Mediator;
 using Microsoft.EntityFrameworkCore;
 using Musify.Application.Contracts;
 using Musify.Application.PlayLists.Responses;
 using Musify.Application.Shared;
-using Musify.Domain.ValueObjects;
-using X.PagedList;
-using X.PagedList.EF;
 
 namespace Musify.Application.PlayLists
 {
@@ -15,52 +11,31 @@ namespace Musify.Application.PlayLists
         string? Name,
         int PageNumber,
         int PageSize,
-        bool OnlyPublic = false)
-        : IQuery<ErrorOr<PaginatedResponse<PlayListApplicationResponse>>>;
+        long? ViewerId = null)
+        : IQuery<PaginatedResponse<PlayListApplicationResponse>>;
 
     public class GetPlayListsByUserIdQueryHandler(IDatabase database)
-        : IQueryHandler<GetPlayListsByUserIdQuery, ErrorOr<PaginatedResponse<PlayListApplicationResponse>>>
+        : IQueryHandler<GetPlayListsByUserIdQuery, PaginatedResponse<PlayListApplicationResponse>>
     {
-        public async ValueTask<ErrorOr<PaginatedResponse<PlayListApplicationResponse>>> Handle(GetPlayListsByUserIdQuery request, CancellationToken cancellationToken)
+        public async ValueTask<PaginatedResponse<PlayListApplicationResponse>> Handle(GetPlayListsByUserIdQuery request, CancellationToken cancellationToken)
         {
             var playListsQuery = database.PlayLists
                 .AsNoTracking()
-                .Where(p => p.UserId == request.UserId);
+                .Active()
+                .VisibleTo(request.ViewerId)
+                .Where(playList => playList.OwnerUserId == request.UserId);
 
-            if (request.OnlyPublic)
+            if (!string.IsNullOrWhiteSpace(request.Name))
             {
-                playListsQuery = playListsQuery.Where(p => p.Visibility == PlaylistVisibility.Public);
+                var normalizedName = TextNormalizer.Normalize(request.Name);
+                playListsQuery = playListsQuery.Where(playList => playList.NormalizedName.Contains(normalizedName));
             }
 
-            if (!string.IsNullOrEmpty(request.Name))
-            {
-                var normalizedName = request.Name.Trim().ToUpperInvariant();
-                playListsQuery = playListsQuery.Where(p => p.NormalizedName.Contains(normalizedName));
-            }
-
-            var totalCount = await playListsQuery.CountAsync(cancellationToken);
-
-            var pagedEntities = await playListsQuery
-                .OrderBy(p => p.CreatedAt)
-                .Where(p => p.LifeCycleStatus == LifeCycleStatus.Active)
-                .Select(p => new
-                {
-                    PlayList = p,
-                    TrackCount = p.PlayListTracks.Count,
-                    DurationSeconds = p.PlayListTracks.Sum(plt => (double?)plt.Track.DurationSeconds) ?? 0,
-                    CoverTrackIds = p.PlayListTracks
-                        .OrderBy(plt => plt.Position)
-                        .Take(PlayListApplicationResponse.CoverTrackCount)
-                        .Select(plt => plt.TrackId)
-                        .ToList()
-                })
-                .ToPagedListAsync(request.PageNumber, request.PageSize, totalCount, cancellationToken);
-
-            var pagedPlayLists = new StaticPagedList<PlayListApplicationResponse>(
-                pagedEntities.Select(entry => PlayListApplicationResponse.FromEntity(entry.PlayList, entry.TrackCount, entry.DurationSeconds, entry.CoverTrackIds)),
-                pagedEntities.PageNumber, pagedEntities.PageSize, pagedEntities.TotalItemCount);
-
-            return PaginatedResponse<PlayListApplicationResponse>.FromPagedList(pagedPlayLists);
+            return await playListsQuery
+                .OrderBy(playList => playList.CreatedAt)
+                .ThenBy(playList => playList.Id)
+                .SelectResponse()
+                .ToPaginatedAsync(new PageRequest(request.PageNumber, request.PageSize), cancellationToken);
         }
     }
 }

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

@@ -3,6 +3,7 @@ using Mediator;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.Logging;
 using Musify.Application.Contracts;
+using Musify.Application.Shared;
 
 namespace Musify.Application.PlayLists
 {
@@ -16,34 +17,30 @@ namespace Musify.Application.PlayLists
     {
         public async ValueTask<ErrorOr<Success>> Handle(RemoveTrackFromPlayListCommand request, CancellationToken cancellationToken)
         {
-            var playList = await database.PlayLists
-                .SingleOrDefaultAsync(pl => pl.Id == request.PlayListId, cancellationToken);
-            if (playList == null)
-            {
-                logger.LogInformation("Playlist {PlayListId} not found", request.PlayListId);
-                return Error.NotFound();
-            }
+            var playList = await database.PlayLists.FindOwnedAsync(request.PlayListId, request.UserId, cancellationToken);
+            if (playList.IsError)
+                return playList.Errors;
 
-            if (playList.UserId != request.UserId)
-            {
-                logger.LogWarning("User {UserId} is not the owner of playlist {PlayListId}", request.UserId, request.PlayListId);
-                return Error.Unauthorized();
-            }
+            var playListTracks = await database.PlayListHasTracks
+                .Where(plt => plt.PlayListId == request.PlayListId)
+                .OrderBy(plt => plt.Position)
+                .ToListAsync(cancellationToken);
 
-            var link = await database.PlayListHasTracks
-                .SingleOrDefaultAsync(plt => plt.PlayListId == request.PlayListId && plt.TrackId == request.TrackId, cancellationToken);
+            var link = playListTracks.SingleOrDefault(plt => plt.TrackId == request.TrackId);
             if (link == null)
-            {
-                logger.LogInformation("Track {TrackId} not in playlist {PlayListId}", request.TrackId, request.PlayListId);
-                return Error.NotFound(description: "Track is not in the playlist.");
-            }
+                return Error.NotFound("PlayList.TrackNotFound", "Track is not in the playlist.");
 
             database.PlayListHasTracks.Remove(link);
+
+            var position = 0;
+            foreach (var remaining in playListTracks.Where(plt => plt.Id != link.Id))
+                remaining.Position = position++;
+
             await database.SaveChangesAsync(cancellationToken);
 
             logger.LogInformation("Removed track {TrackId} from playlist {PlayListId}", request.TrackId, request.PlayListId);
 
-            return new Success();
+            return Result.Success;
         }
     }
 }

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

@@ -1,13 +1,9 @@
 using ErrorOr;
 using Mediator;
-using Microsoft.EntityFrameworkCore;
-using Microsoft.Extensions.Logging;
 using Musify.Application.Configuration;
-using Musify.Application.PlayLists.Responses;
+using Musify.Application.Pictures.Responses;
 using Musify.Application.Services;
-using Musify.Domain.Entities;
 using Musify.Domain.ValueObjects;
-using Musify.Application.Contracts;
 
 namespace Musify.Application.PlayLists
 {
@@ -16,90 +12,14 @@ namespace Musify.Application.PlayLists
         string FileType,
         string ContentType,
         long? ExpectedSizeBytes = null)
-        : ICommand<ErrorOr<PlayListPictureUploadResponse>>;
+        : ICommand<ErrorOr<PictureUploadResponse>>;
 
-    public class RequestPlayListPictureUploadCommandHandler(
-        IDatabase database,
-        UploadIntentValidator uploadIntentValidator,
-        IStorageService storageService,
-        ILogger<RequestPlayListPictureUploadCommandHandler> logger,
-        ApplicationStorageConfiguration storageConfiguration,
-        PlayListConfiguration playListConfiguration,
-        UploadIntentConfiguration uploadIntentConfiguration)
-        : ICommandHandler<RequestPlayListPictureUploadCommand, ErrorOr<PlayListPictureUploadResponse>>
+    public class RequestPlayListPictureUploadCommandHandler(UploadIntentIssuer issuer, PlayListConfiguration playListConfiguration)
+        : ICommandHandler<RequestPlayListPictureUploadCommand, ErrorOr<PictureUploadResponse>>
     {
-        public async ValueTask<ErrorOr<PlayListPictureUploadResponse>> Handle(RequestPlayListPictureUploadCommand request, CancellationToken cancellationToken)
-        {
-            var userExists = await database.Users
-                .AsNoTracking()
-                .AnyAsync(u => u.Id == request.UserId, cancellationToken);
-            if (!userExists)
-            {
-                logger.LogWarning("User {UserId} not found", request.UserId);
-                return Error.NotFound(description: $"User {request.UserId} not found");
-            }
-
-            var effectiveSizeBytes = request.ExpectedSizeBytes
-                ?? uploadIntentConfiguration.DefaultExpectedPictureSizeBytes;
-
-            var objectName = $"{Guid.NewGuid()}.{request.FileType.TrimStart('.').ToLowerInvariant()}";
-
-            var tempKey = playListConfiguration.Routes.BuildTempPicturePath(
-                uploadIntentConfiguration.TemporalRootPrefix, request.UserId, objectName);
-
-            try
-            {
-                var uploadUrl = await storageService.GetUploadUrlAsync(
-                    storageConfiguration.Bucket,
-                    tempKey,
-                    request.ContentType,
-                    TimeSpan.FromSeconds(uploadIntentConfiguration.UploadUrlExpiresInSeconds),
-                    cancellationToken);
-
-                await using var transaction = await database.BeginTransactionAsync(
-                    System.Data.IsolationLevel.Serializable, cancellationToken);
-
-                var quotaCheck = await uploadIntentValidator.CheckQuotaAsync(
-                    uploadIntentConfiguration,
-                    request.UserId, effectiveSizeBytes, 1, cancellationToken);
-                if (quotaCheck.IsError)
-                {
-                    logger.LogWarning("User {UserId} failed upload intent quota check", request.UserId);
-                    return quotaCheck.Errors;
-                }
-
-                var intent = new UploadIntent
-                {
-                    UserId = request.UserId,
-                    Bucket = storageConfiguration.Bucket,
-                    Key = tempKey,
-                    ObjectName = objectName,
-                    ContentType = request.ContentType,
-                    ExpectedSizeBytes = effectiveSizeBytes,
-                    Purpose = UploadIntentPurpose.PlayListPicture,
-                    ExpiresAt = DateTime.UtcNow.AddSeconds(uploadIntentConfiguration.UploadUrlExpiresInSeconds),
-                };
-
-                await database.UploadIntents.AddAsync(intent, cancellationToken);
-                await database.SaveChangesAsync(cancellationToken);
-                await transaction.CommitAsync(cancellationToken);
-
-                logger.LogInformation("Issued upload intent {IntentId} for user {UserId} (PlayListPicture, temp key: {Key})", intent.Id, request.UserId, tempKey);
-
-                return new PlayListPictureUploadResponse(
-                    intent.Id,
-                    storageConfiguration.Bucket,
-                    tempKey,
-                    objectName,
-                    request.ContentType,
-                    uploadIntentConfiguration.UploadUrlExpiresInSeconds,
-                    uploadUrl);
-            }
-            catch (Exception exception)
-            {
-                logger.LogError(exception, "Failed to generate playlist picture upload URL for user {UserId}", request.UserId);
-                return Error.Failure(description: "Failed to generate upload URL");
-            }
-        }
+        public async ValueTask<ErrorOr<PictureUploadResponse>> Handle(RequestPlayListPictureUploadCommand request, CancellationToken cancellationToken) =>
+            await issuer.IssuePictureAsync(
+                request.UserId, UploadIntentPurpose.PlayListPicture, playListConfiguration,
+                request.FileType, request.ContentType, request.ExpectedSizeBytes, cancellationToken);
     }
 }

backend/Core/Musify.Application/PlayLists/Responses/PlayListApplicationResponse.cs

@@ -1,8 +1,7 @@
-using System.Text.Json.Serialization;
-using Musify.Application.Serialization;
 using Musify.Domain.Entities;
 using Musify.Domain.ValueObjects;
 
+
 namespace Musify.Application.PlayLists.Responses
 {
     public record PlayListApplicationResponse(
@@ -12,21 +11,21 @@ namespace Musify.Application.PlayLists.Responses
         string? SmallImageKeyName,
         string? MediumImageKeyName,
         string? LargeImageKeyName,
-        [property: JsonConverter(typeof(LongAsStringConverter))] long OwnerUserId,
-        PlaylistVisibility Visibility,
-        int TrackCount,
-        double DurationSeconds,
+        PlayListVisibility Visibility,
         DateTime CreatedAt,
         DateTime UpdatedAt,
-        IReadOnlyList<Guid> CoverTrackIds)
+        IReadOnlyList<Guid> CoverTrackIds,
+        long OwnerUserId,
+        int TrackCount,
+        double DurationSeconds)
     {
-        public const int CoverTrackCount = 4;
+        public const int CoverTrackCount = PlayListProjections.CoverTrackCount;
 
         public static PlayListApplicationResponse FromEntity(
             PlayList playList,
+            IReadOnlyList<Guid>? coverTrackIds = null,
             int trackCount = 0,
-            double durationSeconds = 0,
-            IReadOnlyList<Guid>? coverTrackIds = null)
+            double durationSeconds = 0)
         {
             return new PlayListApplicationResponse(
                 playList.Id,
@@ -35,13 +34,13 @@ namespace Musify.Application.PlayLists.Responses
                 playList.Pictures?.SmallName,
                 playList.Pictures?.MediumName,
                 playList.Pictures?.LargeName,
-                playList.UserId,
                 playList.Visibility,
-                trackCount,
-                durationSeconds,
                 playList.CreatedAt,
                 playList.UpdatedAt,
-                coverTrackIds ?? []);
+                coverTrackIds ?? [],
+                playList.OwnerUserId,
+                trackCount,
+                durationSeconds);
         }
     }
 }

backend/Core/Musify.Application/PlayLists/Responses/PlayListPictureUploadResponse.cs

@@ -1,11 +0,0 @@
-namespace Musify.Application.PlayLists.Responses
-{
-    public record PlayListPictureUploadResponse(
-        Guid IntentId,
-        string Bucket,
-        string Key,
-        string PictureName,
-        string ContentType,
-        int ExpiresInSeconds,
-        string UploadUrl);
-}

backend/Core/Musify.Application/PlayLists/Responses/PlayListProjections.cs

@@ -0,0 +1,38 @@
+using Musify.Domain.Entities;
+using Musify.Domain.ValueObjects;
+
+namespace Musify.Application.PlayLists.Responses
+{
+    public static class PlayListProjections
+    {
+        public const int CoverTrackCount = 4;
+
+        public static IQueryable<PlayList> Active(this IQueryable<PlayList> query) =>
+            query.Where(playList => playList.LifeCycleStatus == LifeCycleStatus.Active);
+
+        public static IQueryable<PlayList> VisibleTo(this IQueryable<PlayList> query, long? viewerId) =>
+            query.Where(playList => playList.Visibility == PlayListVisibility.Public || playList.OwnerUserId == viewerId);
+
+        public static IQueryable<PlayListApplicationResponse> SelectResponse(this IQueryable<PlayList> query) =>
+            query.Select(playList => new PlayListApplicationResponse(
+                playList.Id,
+                playList.Name,
+                playList.Description,
+                playList.Pictures!.SmallName,
+                playList.Pictures!.MediumName,
+                playList.Pictures!.LargeName,
+                playList.Visibility,
+                playList.CreatedAt,
+                playList.UpdatedAt,
+                playList.PlayListTracks
+                    .OrderBy(playListTrack => playListTrack.Position)
+                    .Take(CoverTrackCount)
+                    .Select(playListTrack => playListTrack.TrackId)
+                    .ToList(),
+                playList.OwnerUserId,
+                playList.PlayListTracks.Count(playListTrack => playListTrack.Track.LifeCycleStatus == LifeCycleStatus.Active),
+                playList.PlayListTracks
+                    .Where(playListTrack => playListTrack.Track.LifeCycleStatus == LifeCycleStatus.Active)
+                    .Sum(playListTrack => playListTrack.Track.DurationSeconds)));
+    }
+}

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

@@ -3,13 +3,13 @@ using Mediator;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.Logging;
 using Musify.Application.Configuration;
-using Musify.Application.Shared;
+using Musify.Application.Contracts;
 using Musify.Application.Events;
+using Musify.Application.Pictures;
 using Musify.Application.PlayLists.Responses;
 using Musify.Application.Services;
-using Musify.Domain.Entities;
+using Musify.Application.Shared;
 using Musify.Domain.ValueObjects;
-using Musify.Application.Contracts;
 
 namespace Musify.Application.PlayLists
 {
@@ -19,7 +19,7 @@ namespace Musify.Application.PlayLists
         string? NewName,
         string? NewDescription,
         Guid? NewPictureIntentId,
-        PlaylistVisibility? NewVisibility = null)
+        PlayListVisibility? NewVisibility = null)
         : ICommand<ErrorOr<PlayListApplicationResponse>>;
 
     public class UpdatePlayListCommandHandler(
@@ -27,144 +27,55 @@ namespace Musify.Application.PlayLists
         IDatabase database,
         UploadIntentValidator uploadIntentValidator,
         ILogger<UpdatePlayListCommandHandler> logger,
-        ApplicationStorageConfiguration storageConfiguration,
-        PlayListConfiguration playListConfiguration,
-        UploadIntentConfiguration uploadIntentConfiguration)
+        PlayListConfiguration playListConfiguration)
         : ICommandHandler<UpdatePlayListCommand, ErrorOr<PlayListApplicationResponse>>
     {
         public async ValueTask<ErrorOr<PlayListApplicationResponse>> Handle(UpdatePlayListCommand request, CancellationToken cancellationToken)
         {
-            var playListEntity = await database.PlayLists.SingleOrDefaultAsync(pl => pl.Id == request.PlayListId, cancellationToken);
-            if (playListEntity == null)
-            {
-                logger.LogInformation("Playlist {PlayListId} not found", request.PlayListId);
-                return Error.NotFound();
-            }
+            var found = await database.PlayLists.FindOwnedAsync(request.PlayListId, request.UserId, cancellationToken);
+            if (found.IsError)
+                return found.Errors;
 
-            if (playListEntity.UserId != request.UserId)
-            {
-                logger.LogWarning("User {UserId} is not the owner of playlist {PlayListId}", request.UserId, request.PlayListId);
-                return Error.Unauthorized();
-            }
+            var playList = found.Value;
 
             if (!string.IsNullOrWhiteSpace(request.NewName))
             {
-                playListEntity.Name = request.NewName;
-                playListEntity.NormalizedName = request.NewName.Trim().ToUpperInvariant();
+                playList.Name = request.NewName.Trim();
+                playList.NormalizedName = TextNormalizer.Normalize(request.NewName);
             }
 
-            if (!string.IsNullOrWhiteSpace(request.NewDescription))
+            // null means "unchanged"; a blank description clears it.
+            if (request.NewDescription != null)
+                playList.Description = string.IsNullOrWhiteSpace(request.NewDescription) ? null : request.NewDescription.Trim();
+
+            if (request.NewVisibility is { } visibility)
+                playList.Visibility = visibility;
+
+            if (request.NewPictureIntentId is { } intentId)
             {
-                playListEntity.Description = request.NewDescription;
-            }
+                var prepared = await PictureSourceChange.PrepareAsync(
+                    uploadIntentValidator, intentId, request.UserId, UploadIntentPurpose.PlayListPicture, playListConfiguration, cancellationToken);
+                if (prepared.IsError)
+                    return prepared.Errors;
 
-            if (request.NewVisibility.HasValue)
-            {
-                playListEntity.Visibility = request.NewVisibility.Value;
-            }
+                var picture = prepared.Value;
+                playList.Pictures = picture.Pictures;
 
-            UploadIntent? pictureIntent = null;
-            string? finalPictureKey = null;
-
-            if (request.NewPictureIntentId.HasValue)
-            {
-                var validation = await uploadIntentValidator.ValidateAndLoadAsync(
-                    uploadIntentConfiguration,
-                    request.NewPictureIntentId.Value, request.UserId, cancellationToken);
-                if (validation.IsError)
-                    return validation.Errors;
-
-                pictureIntent = validation.Value;
-                playListEntity.Pictures = new PlayListPictures
-                {
-                    OriginalName = pictureIntent.ObjectName,
-                    SmallName = pictureIntent.ObjectName,
-                    MediumName = pictureIntent.ObjectName,
-                    LargeName = pictureIntent.ObjectName
-                };
-                finalPictureKey = playListConfiguration.Routes.BuildOriginalPicturePath(request.UserId, pictureIntent.ObjectName);
-            }
-
-            if (pictureIntent != null && finalPictureKey != null)
-            {
-                var publishResult = await PublishUpdatePlayListPictureSourceEventAsync(
-                    playListEntity.Id, pictureIntent, finalPictureKey, cancellationToken);
-                if (publishResult.IsError)
-                    return publishResult.Errors;
-            }
-
-            try
-            {
-                await database.SaveChangesAsync(cancellationToken);
-            }
-            catch (Exception exception)
-            {
-                logger.LogError(exception, "Failed to update playlist {PlayListId}", playListEntity.Id);
-                return Error.Failure(description: $"Failed to update playlist {playListEntity.Id}");
-            }
-
-            var coverTrackIds = await database.PlayListHasTracks
-                .AsNoTracking()
-                .Where(plt => plt.PlayListId == playListEntity.Id)
-                .OrderBy(plt => plt.Position)
-                .Take(PlayListApplicationResponse.CoverTrackCount)
-                .Select(plt => plt.TrackId)
-                .ToListAsync(cancellationToken);
-
-            logger.LogInformation("Updated playlist {PlayListId}", playListEntity.Id);
-            var totals = await database.PlayListHasTracks
-                .AsNoTracking()
-                .Where(plt => plt.PlayListId == playListEntity.Id)
-                .GroupBy(plt => plt.PlayListId)
-                .Select(group => new
-                {
-                    TrackCount = group.Count(),
-                    DurationSeconds = group.Sum(plt => plt.Track.DurationSeconds)
-                })
-                .SingleOrDefaultAsync(cancellationToken);
-
-            return PlayListApplicationResponse.FromEntity(
-                playListEntity,
-                totals?.TrackCount ?? 0,
-                totals?.DurationSeconds ?? 0,
-                coverTrackIds);
-        }
-
-        private async Task<ErrorOr<Success>> PublishUpdatePlayListPictureSourceEventAsync(
-            Guid playListId,
-            UploadIntent pictureIntent,
-            string finalPictureKey,
-            CancellationToken cancellationToken)
-        {
-            try
-            {
                 await eventBus.PublishAsync(
                     new UpdatePlayListPictureSourceEvent(
-                        playListId,
-                        pictureIntent.Id,
-                        storageConfiguration.Bucket,
-                        pictureIntent.Key,
-                        finalPictureKey,
-                        new ImageSize(
-                            playListConfiguration.Routes.SmallPicturesPath,
-                            playListConfiguration.PicturesSizes.SmallPictureWidth,
-                            playListConfiguration.PicturesSizes.SmallPictureHeight),
-                        new ImageSize(
-                            playListConfiguration.Routes.MediumPicturesPath,
-                            playListConfiguration.PicturesSizes.MediumPictureWidth,
-                            playListConfiguration.PicturesSizes.MediumPictureHeight),
-                        new ImageSize(
-                            playListConfiguration.Routes.LargePicturesPath,
-                            playListConfiguration.PicturesSizes.LargePictureWidth,
-                            playListConfiguration.PicturesSizes.LargePictureHeight)),
+                        playList.Id, picture.Intent.Id, picture.Intent.Bucket, picture.Intent.Key, picture.FinalKey, picture.Sizes),
                     cancellationToken);
-                return new Success();
-            }
-            catch (Exception exception)
-            {
-                logger.LogError(exception, "Failed to publish update playlist picture source event for playlist {PlayListId}", playListId);
-                return Error.Failure(description: $"Failed to publish update playlist picture source event for playlist {playListId}");
             }
+
+            await database.SaveChangesAsync(cancellationToken);
+
+            logger.LogInformation("Updated playlist {PlayListId}", playList.Id);
+
+            return await database.PlayLists
+                .AsNoTracking()
+                .Where(p => p.Id == playList.Id)
+                .SelectResponse()
+                .SingleAsync(cancellationToken);
         }
     }
 }