Add editorconfig and analyzers, format backend code

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

@@ -5,71 +5,70 @@ using Microsoft.Extensions.Logging;
 using Musify.Application.Contracts;
 using Musify.Domain.Entities;
 
-namespace Musify.Application.PlayLists
+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 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)
     {
-        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)
         {
-            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();
+            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/CreatePlayList.cs

@@ -3,144 +3,143 @@ 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.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
+namespace Musify.Application.PlayLists;
+
+public record CreatePlayListCommand(
+    long UserId,
+    string Name,
+    string? Description,
+    Guid? PictureIntentId,
+    PlaylistVisibility Visibility = PlaylistVisibility.Private)
+    : ICommand<ErrorOr<PlayListApplicationResponse>>;
+
+public class CreatePlayListCommandHandler(
+    IEventBus eventBus,
+    IDatabase database,
+    UploadIntentValidator uploadIntentValidator,
+    ILogger<CreatePlayListCommandHandler> logger,
+    ApplicationStorageConfiguration storageConfiguration,
+    PlayListConfiguration playListConfiguration,
+    UploadIntentConfiguration uploadIntentConfiguration)
+    : ICommandHandler<CreatePlayListCommand, ErrorOr<PlayListApplicationResponse>>
 {
-    public record CreatePlayListCommand(
-        long UserId,
-        string Name,
-        string? Description,
-        Guid? PictureIntentId,
-        PlaylistVisibility Visibility = PlaylistVisibility.Private)
-        : ICommand<ErrorOr<PlayListApplicationResponse>>;
+    private sealed record ResolvedPlayListPictures(PlayListPictures? Pictures, UploadIntent? Intent);
 
-    public class CreatePlayListCommandHandler(
-        IEventBus eventBus,
-        IDatabase database,
-        UploadIntentValidator uploadIntentValidator,
-        ILogger<CreatePlayListCommandHandler> logger,
-        ApplicationStorageConfiguration storageConfiguration,
-        PlayListConfiguration playListConfiguration,
-        UploadIntentConfiguration uploadIntentConfiguration)
-        : ICommandHandler<CreatePlayListCommand, ErrorOr<PlayListApplicationResponse>>
+    public async ValueTask<ErrorOr<PlayListApplicationResponse>> Handle(CreatePlayListCommand request, CancellationToken cancellationToken)
     {
-        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)
         {
-            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 picturesResult = await ResolvePicturesAsync(request, cancellationToken);
-            if (picturesResult.IsError)
-                return picturesResult.Errors;
-
-            var resolvedPictures = picturesResult.Value;
-
-            var playList = new PlayList
-            {
-                UserId = request.UserId,
-                Name = request.Name,
-                NormalizedName = request.Name.Trim().ToUpperInvariant(),
-                Description = string.IsNullOrWhiteSpace(request.Description) ? null : request.Description.Trim(),
-                Pictures = resolvedPictures.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);
+            logger.LogWarning("User {UserId} not found", request.UserId);
+            return Error.NotFound(description: $"User {request.UserId} not found");
         }
 
-        private async ValueTask<ErrorOr<ResolvedPlayListPictures>> ResolvePicturesAsync(
-            CreatePlayListCommand request, CancellationToken cancellationToken)
+        var picturesResult = await ResolvePicturesAsync(request, cancellationToken);
+        if (picturesResult.IsError)
+            return picturesResult.Errors;
+
+        var resolvedPictures = picturesResult.Value;
+
+        var playList = new PlayList
         {
-            if (!request.PictureIntentId.HasValue)
-            {
-                return new ResolvedPlayListPictures(null, null);
-            }
+            UserId = request.UserId,
+            Name = request.Name,
+            NormalizedName = request.Name.Trim().ToUpperInvariant(),
+            Description = string.IsNullOrWhiteSpace(request.Description) ? null : request.Description.Trim(),
+            Pictures = resolvedPictures.Pictures,
+            Visibility = request.Visibility
+        };
+        await database.PlayLists.AddAsync(playList, cancellationToken);
 
-            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);
+        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;
         }
 
-        private async Task<ErrorOr<Success>> PublishCreatePlayListEventAsync(
-            Guid playListId,
-            UploadIntent pictureIntent,
-            string finalPictureKey,
-            CancellationToken cancellationToken)
+        try
         {
-            try
-            {
-                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)),
-                    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);
+        }
+        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
+        {
+            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)),
+                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}");
         }
     }
 }

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

@@ -6,57 +6,56 @@ using Musify.Application.Contracts;
 using Musify.Application.Events;
 using Musify.Domain.ValueObjects;
 
-namespace Musify.Application.PlayLists
+namespace Musify.Application.PlayLists;
+
+public record DeletePlayListCommand(long UserId, Guid PlayListId)
+    : ICommand<ErrorOr<Success>>;
+
+public class DeletePlayListCommandHandler(
+    IDatabase database,
+    IEventBus eventBus,
+    ILogger<DeletePlayListCommandHandler> logger)
+    : ICommandHandler<DeletePlayListCommand, ErrorOr<Success>>
 {
-    public record DeletePlayListCommand(long UserId, Guid PlayListId)
-        : ICommand<ErrorOr<Success>>;
-
-    public class DeletePlayListCommandHandler(
-        IDatabase database,
-        IEventBus eventBus,
-        ILogger<DeletePlayListCommandHandler> logger)
-        : ICommandHandler<DeletePlayListCommand, ErrorOr<Success>>
+    public async ValueTask<ErrorOr<Success>> Handle(DeletePlayListCommand request, CancellationToken cancellationToken)
     {
-        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)
         {
-            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();
-            }
-
-            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}");
-            }
-
-            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}");
-            }
-
-            return new Success();
+            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();
+        }
+
+        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}");
+        }
+
+        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}");
+        }
+
+        return new Success();
     }
 }

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

@@ -1,42 +1,43 @@
 using ErrorOr;
-using Microsoft.EntityFrameworkCore;
-using Musify.Application.PlayLists.Responses;
 using Mediator;
+using Microsoft.EntityFrameworkCore;
 using Musify.Application.Contracts;
+using Musify.Application.PlayLists.Responses;
 using Musify.Domain.ValueObjects;
 
-namespace Musify.Application.PlayLists
+namespace Musify.Application.PlayLists;
+
+public record GetPlayListByIdQuery(Guid Id, long? RequestingUserId = null)
+    : IQuery<ErrorOr<PlayListApplicationResponse>>;
+
+public class GetPlayListByIdQueryHandler(IDatabase database)
+    : IQueryHandler<GetPlayListByIdQuery, ErrorOr<PlayListApplicationResponse>>
 {
-    public record GetPlayListByIdQuery(Guid Id, long? RequestingUserId = null)
-        : IQuery<ErrorOr<PlayListApplicationResponse>>;
-
-    public class GetPlayListByIdQueryHandler(IDatabase database)
-        : IQueryHandler<GetPlayListByIdQuery, ErrorOr<PlayListApplicationResponse>>
+    public async ValueTask<ErrorOr<PlayListApplicationResponse>> Handle(GetPlayListByIdQuery request, CancellationToken cancellationToken)
     {
-        public async ValueTask<ErrorOr<PlayListApplicationResponse>> Handle(GetPlayListByIdQuery request, CancellationToken cancellationToken)
+        var entry = await database.PlayLists
+            .AsNoTracking()
+            .Where(p => p.Id == request.Id)
+            .Select(p => new
+            {
+                PlayList = p,
+                CoverTrackIds = p.PlayListTracks
+                    .OrderBy(plt => plt.Position)
+                    .Take(PlayListApplicationResponse.CoverTrackCount)
+                    .Select(plt => plt.TrackId)
+                    .ToList()
+            })
+            .SingleOrDefaultAsync(cancellationToken);
+
+        if (entry == null)
+            return Error.NotFound();
+
+        if (entry.PlayList.Visibility == PlaylistVisibility.Private
+            && entry.PlayList.UserId != request.RequestingUserId)
         {
-            var entry = await database.PlayLists
-                .AsNoTracking()
-                .Where(p => p.Id == request.Id)
-                .Select(p => new
-                {
-                    PlayList = p,
-                    CoverTrackIds = p.PlayListTracks
-                        .OrderBy(plt => plt.Position)
-                        .Take(PlayListApplicationResponse.CoverTrackCount)
-                        .Select(plt => plt.TrackId)
-                        .ToList()
-                })
-                .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.CoverTrackIds);
+            return Error.NotFound();
         }
+
+        return PlayListApplicationResponse.FromEntity(entry.PlayList, entry.CoverTrackIds);
     }
 }

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

@@ -5,45 +5,44 @@ using MimeMapping;
 using Musify.Application.Configuration;
 using Musify.Application.Contracts;
 
-namespace Musify.Application.PlayLists
+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 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)
     {
-        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
         {
-            var pictures = await database.PlayLists.AsNoTracking()
-                .Where(p => p.Id == request.PlayListId)
-                .Select(p => p.Pictures)
-                .SingleOrDefaultAsync(cancellationToken);
+            "small" => (pictures.SmallName, BuildKey(routes.BuildSmallPicturePath, pictures.SmallName)),
+            "large" => (pictures.LargeName, BuildKey(routes.BuildLargePicturePath, pictures.LargeName)),
+            _ => (pictures.MediumName, BuildKey(routes.BuildMediumPicturePath, pictures.MediumName))
+        };
 
-            if (pictures == null)
-                return Error.NotFound();
+        if (string.IsNullOrEmpty(name) || string.IsNullOrEmpty(key))
+            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);
+        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

@@ -7,43 +7,42 @@ using Musify.Application.Tracks.Responses;
 using X.PagedList;
 using X.PagedList.EF;
 
-namespace Musify.Application.PlayLists
+namespace Musify.Application.PlayLists;
+
+public record GetPlayListTracksQuery(
+    Guid PlayListId,
+    int PageNumber,
+    int PageSize)
+    : IQuery<ErrorOr<PaginatedResponse<TrackApplicationResponse>>>;
+
+public class GetPlayListTracksQueryHandler(IDatabase database)
+    : IQueryHandler<GetPlayListTracksQuery, ErrorOr<PaginatedResponse<TrackApplicationResponse>>>
 {
-    public record GetPlayListTracksQuery(
-        Guid PlayListId,
-        int PageNumber,
-        int PageSize)
-        : IQuery<ErrorOr<PaginatedResponse<TrackApplicationResponse>>>;
-
-    public class GetPlayListTracksQueryHandler(IDatabase database)
-        : IQueryHandler<GetPlayListTracksQuery, ErrorOr<PaginatedResponse<TrackApplicationResponse>>>
+    public async ValueTask<ErrorOr<PaginatedResponse<TrackApplicationResponse>>> Handle(GetPlayListTracksQuery request, CancellationToken cancellationToken)
     {
-        public async ValueTask<ErrorOr<PaginatedResponse<TrackApplicationResponse>>> Handle(GetPlayListTracksQuery request, CancellationToken cancellationToken)
-        {
-            var playListExists = await database.PlayLists
-                .AsNoTracking()
-                .AnyAsync(p => p.Id == request.PlayListId, cancellationToken);
-            if (!playListExists)
-                return Error.NotFound();
+        var playListExists = await database.PlayLists
+            .AsNoTracking()
+            .AnyAsync(p => p.Id == request.PlayListId, cancellationToken);
+        if (!playListExists)
+            return Error.NotFound();
 
-            var tracksQuery = database.PlayListHasTracks
-                .AsNoTracking()
-                .Include(plt => plt.Track.Owner)
-                .Include(plt => plt.Track.Tags)
-                .Where(plt => plt.PlayListId == request.PlayListId);
+        var tracksQuery = 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 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 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);
+        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);
-        }
+        return PaginatedResponse<TrackApplicationResponse>.FromPagedList(pagedTracks);
     }
 }

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

@@ -1,43 +1,42 @@
 using ErrorOr;
+using Mediator;
 using Microsoft.EntityFrameworkCore;
-using Musify.Application.Shared;
+using Musify.Application.Contracts;
 using Musify.Application.PlayLists.Responses;
+using Musify.Application.Shared;
 using X.PagedList;
 using X.PagedList.EF;
-using Mediator;
-using Musify.Application.Contracts;
 
-namespace Musify.Application.PlayLists
+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 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)
     {
-        public async ValueTask<ErrorOr<PaginatedResponse<PlayListApplicationResponse>>> Handle(GetPlayListsQuery request, CancellationToken cancellationToken)
-        {
-            var totalCount = await database.PlayLists.CountAsync(cancellationToken);
+        var totalCount = await database.PlayLists.CountAsync(cancellationToken);
 
-            var pagedEntities = await database.PlayLists
-                .AsNoTracking()
-                .OrderBy(p => p.Id)
-                .Select(p => new
-                {
-                    PlayList = p,
-                    CoverTrackIds = p.PlayListTracks
-                        .OrderBy(plt => plt.Position)
-                        .Take(PlayListApplicationResponse.CoverTrackCount)
-                        .Select(plt => plt.TrackId)
-                        .ToList()
-                })
-                .ToPagedListAsync(request.PageNumber, request.PageSize, totalCount, cancellationToken);
+        var pagedEntities = await database.PlayLists
+            .AsNoTracking()
+            .OrderBy(p => p.Id)
+            .Select(p => new
+            {
+                PlayList = p,
+                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.CoverTrackIds)),
-                pagedEntities.PageNumber, pagedEntities.PageSize, pagedEntities.TotalItemCount);
+        var pagedPlayLists = new StaticPagedList<PlayListApplicationResponse>(
+            pagedEntities.Select(entry => PlayListApplicationResponse.FromEntity(entry.PlayList, entry.CoverTrackIds)),
+            pagedEntities.PageNumber, pagedEntities.PageSize, pagedEntities.TotalItemCount);
 
-            return PaginatedResponse<PlayListApplicationResponse>.FromPagedList(pagedPlayLists);
-        }
+        return PaginatedResponse<PlayListApplicationResponse>.FromPagedList(pagedPlayLists);
     }
 }

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

@@ -8,57 +8,56 @@ using Musify.Domain.ValueObjects;
 using X.PagedList;
 using X.PagedList.EF;
 
-namespace Musify.Application.PlayLists
+namespace Musify.Application.PlayLists;
+
+public record GetPlayListsByUserIdQuery(
+    long UserId,
+    string? Name,
+    int PageNumber,
+    int PageSize,
+    bool OnlyPublic = false)
+    : IQuery<ErrorOr<PaginatedResponse<PlayListApplicationResponse>>>;
+
+public class GetPlayListsByUserIdQueryHandler(IDatabase database)
+    : IQueryHandler<GetPlayListsByUserIdQuery, ErrorOr<PaginatedResponse<PlayListApplicationResponse>>>
 {
-    public record GetPlayListsByUserIdQuery(
-        long UserId,
-        string? Name,
-        int PageNumber,
-        int PageSize,
-        bool OnlyPublic = false)
-        : IQuery<ErrorOr<PaginatedResponse<PlayListApplicationResponse>>>;
-
-    public class GetPlayListsByUserIdQueryHandler(IDatabase database)
-        : IQueryHandler<GetPlayListsByUserIdQuery, ErrorOr<PaginatedResponse<PlayListApplicationResponse>>>
+    public async ValueTask<ErrorOr<PaginatedResponse<PlayListApplicationResponse>>> Handle(GetPlayListsByUserIdQuery request, CancellationToken cancellationToken)
     {
-        public async ValueTask<ErrorOr<PaginatedResponse<PlayListApplicationResponse>>> Handle(GetPlayListsByUserIdQuery request, CancellationToken cancellationToken)
+        var playListsQuery = database.PlayLists
+            .AsNoTracking()
+            .Where(p => p.UserId == request.UserId);
+
+        if (request.OnlyPublic)
         {
-            var playListsQuery = database.PlayLists
-                .AsNoTracking()
-                .Where(p => p.UserId == request.UserId);
-
-            if (request.OnlyPublic)
-            {
-                playListsQuery = playListsQuery.Where(p => p.Visibility == PlaylistVisibility.Public);
-            }
-
-            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,
-                    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.CoverTrackIds)),
-                pagedEntities.PageNumber, pagedEntities.PageSize, pagedEntities.TotalItemCount);
-
-            return PaginatedResponse<PlayListApplicationResponse>.FromPagedList(pagedPlayLists);
+            playListsQuery = playListsQuery.Where(p => p.Visibility == PlaylistVisibility.Public);
         }
+
+        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,
+                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.CoverTrackIds)),
+            pagedEntities.PageNumber, pagedEntities.PageSize, pagedEntities.TotalItemCount);
+
+        return PaginatedResponse<PlayListApplicationResponse>.FromPagedList(pagedPlayLists);
     }
 }

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

@@ -4,46 +4,45 @@ using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.Logging;
 using Musify.Application.Contracts;
 
-namespace Musify.Application.PlayLists
+namespace Musify.Application.PlayLists;
+
+public record RemoveTrackFromPlayListCommand(long UserId, Guid PlayListId, Guid TrackId)
+    : ICommand<ErrorOr<Success>>;
+
+public class RemoveTrackFromPlayListCommandHandler(
+    IDatabase database,
+    ILogger<RemoveTrackFromPlayListCommandHandler> logger)
+    : ICommandHandler<RemoveTrackFromPlayListCommand, ErrorOr<Success>>
 {
-    public record RemoveTrackFromPlayListCommand(long UserId, Guid PlayListId, Guid TrackId)
-        : ICommand<ErrorOr<Success>>;
-
-    public class RemoveTrackFromPlayListCommandHandler(
-        IDatabase database,
-        ILogger<RemoveTrackFromPlayListCommandHandler> logger)
-        : ICommandHandler<RemoveTrackFromPlayListCommand, ErrorOr<Success>>
+    public async ValueTask<ErrorOr<Success>> Handle(RemoveTrackFromPlayListCommand request, CancellationToken cancellationToken)
     {
-        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)
         {
-            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 link = await database.PlayListHasTracks
-                .SingleOrDefaultAsync(plt => plt.PlayListId == request.PlayListId && plt.TrackId == request.TrackId, cancellationToken);
-            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.");
-            }
-
-            database.PlayListHasTracks.Remove(link);
-            await database.SaveChangesAsync(cancellationToken);
-
-            logger.LogInformation("Removed track {TrackId} from playlist {PlayListId}", request.TrackId, request.PlayListId);
-
-            return new Success();
+            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 link = await database.PlayListHasTracks
+            .SingleOrDefaultAsync(plt => plt.PlayListId == request.PlayListId && plt.TrackId == request.TrackId, cancellationToken);
+        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.");
+        }
+
+        database.PlayListHasTracks.Remove(link);
+        await database.SaveChangesAsync(cancellationToken);
+
+        logger.LogInformation("Removed track {TrackId} from playlist {PlayListId}", request.TrackId, request.PlayListId);
+
+        return new Success();
     }
 }

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

@@ -3,103 +3,102 @@ using Mediator;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.Logging;
 using Musify.Application.Configuration;
+using Musify.Application.Contracts;
 using Musify.Application.PlayLists.Responses;
 using Musify.Application.Services;
 using Musify.Domain.Entities;
 using Musify.Domain.ValueObjects;
-using Musify.Application.Contracts;
 
-namespace Musify.Application.PlayLists
+namespace Musify.Application.PlayLists;
+
+public record RequestPlayListPictureUploadCommand(
+    long UserId,
+    string FileType,
+    string ContentType,
+    long? ExpectedSizeBytes = null)
+    : ICommand<ErrorOr<PlayListPictureUploadResponse>>;
+
+public class RequestPlayListPictureUploadCommandHandler(
+    IDatabase database,
+    UploadIntentValidator uploadIntentValidator,
+    IStorageService storageService,
+    ILogger<RequestPlayListPictureUploadCommandHandler> logger,
+    ApplicationStorageConfiguration storageConfiguration,
+    PlayListConfiguration playListConfiguration,
+    UploadIntentConfiguration uploadIntentConfiguration)
+    : ICommandHandler<RequestPlayListPictureUploadCommand, ErrorOr<PlayListPictureUploadResponse>>
 {
-    public record RequestPlayListPictureUploadCommand(
-        long UserId,
-        string FileType,
-        string ContentType,
-        long? ExpectedSizeBytes = null)
-        : ICommand<ErrorOr<PlayListPictureUploadResponse>>;
-
-    public class RequestPlayListPictureUploadCommandHandler(
-        IDatabase database,
-        UploadIntentValidator uploadIntentValidator,
-        IStorageService storageService,
-        ILogger<RequestPlayListPictureUploadCommandHandler> logger,
-        ApplicationStorageConfiguration storageConfiguration,
-        PlayListConfiguration playListConfiguration,
-        UploadIntentConfiguration uploadIntentConfiguration)
-        : ICommandHandler<RequestPlayListPictureUploadCommand, ErrorOr<PlayListPictureUploadResponse>>
+    public async ValueTask<ErrorOr<PlayListPictureUploadResponse>> Handle(RequestPlayListPictureUploadCommand request, CancellationToken cancellationToken)
     {
-        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)
         {
-            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} not found", request.UserId);
-                return Error.NotFound(description: $"User {request.UserId} not found");
+                logger.LogWarning("User {UserId} failed upload intent quota check", request.UserId);
+                return quotaCheck.Errors;
             }
 
-            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 intent = new UploadIntent
             {
-                var uploadUrl = await storageService.GetUploadUrlAsync(
-                    storageConfiguration.Bucket,
-                    tempKey,
-                    request.ContentType,
-                    TimeSpan.FromSeconds(uploadIntentConfiguration.UploadUrlExpiresInSeconds),
-                    cancellationToken);
+                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 using var transaction = await database.BeginTransactionAsync(
-                    System.Data.IsolationLevel.Serializable, cancellationToken);
+            await database.UploadIntents.AddAsync(intent, cancellationToken);
+            await database.SaveChangesAsync(cancellationToken);
+            await transaction.CommitAsync(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;
-                }
+            logger.LogInformation("Issued upload intent {IntentId} for user {UserId} (PlayListPicture, temp key: {Key})", intent.Id, request.UserId, tempKey);
 
-                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");
-            }
+            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");
         }
     }
 }

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

@@ -1,37 +1,36 @@
 using Musify.Domain.Entities;
 using Musify.Domain.ValueObjects;
 
-namespace Musify.Application.PlayLists.Responses
-{
-    public record PlayListApplicationResponse(
-        Guid Id,
-        string Name,
-        string? Description,
-        string? SmallImageKeyName,
-        string? MediumImageKeyName,
-        string? LargeImageKeyName,
-        PlaylistVisibility Visibility,
-        DateTime CreatedAt,
-        DateTime UpdatedAt,
-        IReadOnlyList<Guid> CoverTrackIds)
-    {
-        public const int CoverTrackCount = 4;
+namespace Musify.Application.PlayLists.Responses;
 
-        public static PlayListApplicationResponse FromEntity(
-            PlayList playList,
-            IReadOnlyList<Guid>? coverTrackIds = null)
-        {
-            return new PlayListApplicationResponse(
-                playList.Id,
-                playList.Name,
-                playList.Description,
-                playList.Pictures?.SmallName,
-                playList.Pictures?.MediumName,
-                playList.Pictures?.LargeName,
-                playList.Visibility,
-                playList.CreatedAt,
-                playList.UpdatedAt,
-                coverTrackIds ?? []);
-        }
+public record PlayListApplicationResponse(
+    Guid Id,
+    string Name,
+    string? Description,
+    string? SmallImageKeyName,
+    string? MediumImageKeyName,
+    string? LargeImageKeyName,
+    PlaylistVisibility Visibility,
+    DateTime CreatedAt,
+    DateTime UpdatedAt,
+    IReadOnlyList<Guid> CoverTrackIds)
+{
+    public const int CoverTrackCount = 4;
+
+    public static PlayListApplicationResponse FromEntity(
+        PlayList playList,
+        IReadOnlyList<Guid>? coverTrackIds = null)
+    {
+        return new PlayListApplicationResponse(
+            playList.Id,
+            playList.Name,
+            playList.Description,
+            playList.Pictures?.SmallName,
+            playList.Pictures?.MediumName,
+            playList.Pictures?.LargeName,
+            playList.Visibility,
+            playList.CreatedAt,
+            playList.UpdatedAt,
+            coverTrackIds ?? []);
     }
 }

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

@@ -1,11 +1,10 @@
-namespace Musify.Application.PlayLists.Responses
-{
-    public record PlayListPictureUploadResponse(
-        Guid IntentId,
-        string Bucket,
-        string Key,
-        string PictureName,
-        string ContentType,
-        int ExpiresInSeconds,
-        string UploadUrl);
-}
+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/UpdatePlayList.cs

@@ -3,153 +3,152 @@ 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.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
+namespace Musify.Application.PlayLists;
+
+public record UpdatePlayListCommand(
+    long UserId,
+    Guid PlayListId,
+    string? NewName,
+    string? NewDescription,
+    Guid? NewPictureIntentId,
+    PlaylistVisibility? NewVisibility = null)
+    : ICommand<ErrorOr<PlayListApplicationResponse>>;
+
+public class UpdatePlayListCommandHandler(
+    IEventBus eventBus,
+    IDatabase database,
+    UploadIntentValidator uploadIntentValidator,
+    ILogger<UpdatePlayListCommandHandler> logger,
+    ApplicationStorageConfiguration storageConfiguration,
+    PlayListConfiguration playListConfiguration,
+    UploadIntentConfiguration uploadIntentConfiguration)
+    : ICommandHandler<UpdatePlayListCommand, ErrorOr<PlayListApplicationResponse>>
 {
-    public record UpdatePlayListCommand(
-        long UserId,
-        Guid PlayListId,
-        string? NewName,
-        string? NewDescription,
-        Guid? NewPictureIntentId,
-        PlaylistVisibility? NewVisibility = null)
-        : ICommand<ErrorOr<PlayListApplicationResponse>>;
-
-    public class UpdatePlayListCommandHandler(
-        IEventBus eventBus,
-        IDatabase database,
-        UploadIntentValidator uploadIntentValidator,
-        ILogger<UpdatePlayListCommandHandler> logger,
-        ApplicationStorageConfiguration storageConfiguration,
-        PlayListConfiguration playListConfiguration,
-        UploadIntentConfiguration uploadIntentConfiguration)
-        : ICommandHandler<UpdatePlayListCommand, ErrorOr<PlayListApplicationResponse>>
+    public async ValueTask<ErrorOr<PlayListApplicationResponse>> Handle(UpdatePlayListCommand request, CancellationToken cancellationToken)
     {
-        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)
         {
-            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();
-            }
-
-            if (playListEntity.UserId != request.UserId)
-            {
-                logger.LogWarning("User {UserId} is not the owner of playlist {PlayListId}", request.UserId, request.PlayListId);
-                return Error.Unauthorized();
-            }
-
-            if (!string.IsNullOrWhiteSpace(request.NewName))
-            {
-                playListEntity.Name = request.NewName;
-                playListEntity.NormalizedName = request.NewName.Trim().ToUpperInvariant();
-            }
-
-            if (!string.IsNullOrWhiteSpace(request.NewDescription))
-            {
-                playListEntity.Description = request.NewDescription;
-            }
-
-            if (request.NewVisibility.HasValue)
-            {
-                playListEntity.Visibility = request.NewVisibility.Value;
-            }
-
-            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);
-            return PlayListApplicationResponse.FromEntity(playListEntity, coverTrackIds);
+            logger.LogInformation("Playlist {PlayListId} not found", request.PlayListId);
+            return Error.NotFound();
         }
 
-        private async Task<ErrorOr<Success>> PublishUpdatePlayListPictureSourceEventAsync(
-            Guid playListId,
-            UploadIntent pictureIntent,
-            string finalPictureKey,
-            CancellationToken cancellationToken)
+        if (playListEntity.UserId != request.UserId)
         {
-            try
+            logger.LogWarning("User {UserId} is not the owner of playlist {PlayListId}", request.UserId, request.PlayListId);
+            return Error.Unauthorized();
+        }
+
+        if (!string.IsNullOrWhiteSpace(request.NewName))
+        {
+            playListEntity.Name = request.NewName;
+            playListEntity.NormalizedName = request.NewName.Trim().ToUpperInvariant();
+        }
+
+        if (!string.IsNullOrWhiteSpace(request.NewDescription))
+        {
+            playListEntity.Description = request.NewDescription;
+        }
+
+        if (request.NewVisibility.HasValue)
+        {
+            playListEntity.Visibility = request.NewVisibility.Value;
+        }
+
+        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
             {
-                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)),
-                    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}");
-            }
+                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);
+        return PlayListApplicationResponse.FromEntity(playListEntity, 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)),
+                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}");
         }
     }
 }