Change editor rule

backend/Core/Musify.Application/Albums/AddTracksToAlbum.cs

@@ -7,71 +7,72 @@ using Musify.Application.Shared;
 using Musify.Domain.Entities;
 using Musify.Domain.ValueObjects;
 
-namespace Musify.Application.Albums;
-
-/// <summary>Appends your own tracks to an album in the given order, skipping the ones it already has.</summary>
-public record AddTracksToAlbumCommand(long UserId, Guid AlbumId, IReadOnlyList<Guid> TrackIds)
-    : ICommand<ErrorOr<Success>>;
-
-public class AddTracksToAlbumCommandHandler(
-    IDatabase database,
-    ILogger<AddTracksToAlbumCommandHandler> logger)
-    : ICommandHandler<AddTracksToAlbumCommand, ErrorOr<Success>>
+namespace Musify.Application.Albums
 {
-    public async ValueTask<ErrorOr<Success>> Handle(AddTracksToAlbumCommand request, CancellationToken cancellationToken)
+    /// <summary>Appends your own tracks to an album in the given order, skipping the ones it already has.</summary>
+    public record AddTracksToAlbumCommand(long UserId, Guid AlbumId, IReadOnlyList<Guid> TrackIds)
+        : ICommand<ErrorOr<Success>>;
+
+    public class AddTracksToAlbumCommandHandler(
+        IDatabase database,
+        ILogger<AddTracksToAlbumCommandHandler> logger)
+        : ICommandHandler<AddTracksToAlbumCommand, ErrorOr<Success>>
     {
-        var album = await database.Albums.FindOwnedAsync(request.AlbumId, request.UserId, cancellationToken);
-        if (album.IsError)
-            return album.Errors;
-
-        var requestedIds = request.TrackIds.Distinct().ToList();
-
-        var tracks = await database.Tracks
-            .AsNoTracking()
-            .Where(track => requestedIds.Contains(track.Id) && track.LifeCycleStatus == LifeCycleStatus.Active)
-            .Select(track => new { track.Id, track.OwnerUserId })
-            .ToListAsync(cancellationToken);
-
-        var missing = requestedIds.FirstOrDefault(id => tracks.All(track => track.Id != id));
-        if (missing != Guid.Empty)
-            return AppErrors.NotFound("Track", missing);
-
-        var foreign = tracks.FirstOrDefault(track => track.OwnerUserId != request.UserId);
-        if (foreign != null)
-            return AppErrors.Forbidden("Track", foreign.Id);
-
-        var alreadyInAlbum = await database.AlbumHasTracks
-            .AsNoTracking()
-            .Where(link => link.AlbumId == request.AlbumId && requestedIds.Contains(link.TrackId))
-            .Select(link => link.TrackId)
-            .ToListAsync(cancellationToken);
-
-        var toAdd = requestedIds.Where(id => !alreadyInAlbum.Contains(id)).ToList();
-        if (toAdd.Count == 0)
-            return Result.Success;
-
-        // Album track numbers are user-visible, so they start at 1.
-        var nextTrackNumber = (await database.AlbumHasTracks
-            .Where(link => link.AlbumId == request.AlbumId)
-            .MaxAsync(link => (int?)link.TrackNumber, cancellationToken) ?? 0) + 1;
-
-        foreach (var trackId in toAdd)
+        public async ValueTask<ErrorOr<Success>> Handle(AddTracksToAlbumCommand request, CancellationToken cancellationToken)
         {
-            await database.AlbumHasTracks.AddAsync(new AlbumHasTrack
+            var album = await database.Albums.FindOwnedAsync(request.AlbumId, request.UserId, cancellationToken);
+            if (album.IsError)
+                return album.Errors;
+
+            var requestedIds = request.TrackIds.Distinct().ToList();
+
+            var tracks = await database.Tracks
+                .AsNoTracking()
+                .Where(track => requestedIds.Contains(track.Id) && track.LifeCycleStatus == LifeCycleStatus.Active)
+                .Select(track => new { track.Id, track.OwnerUserId })
+                .ToListAsync(cancellationToken);
+
+            var missing = requestedIds.FirstOrDefault(id => tracks.All(track => track.Id != id));
+            if (missing != Guid.Empty)
+                return AppErrors.NotFound("Track", missing);
+
+            var foreign = tracks.FirstOrDefault(track => track.OwnerUserId != request.UserId);
+            if (foreign != null)
+                return AppErrors.Forbidden("Track", foreign.Id);
+
+            var alreadyInAlbum = await database.AlbumHasTracks
+                .AsNoTracking()
+                .Where(link => link.AlbumId == request.AlbumId && requestedIds.Contains(link.TrackId))
+                .Select(link => link.TrackId)
+                .ToListAsync(cancellationToken);
+
+            var toAdd = requestedIds.Where(id => !alreadyInAlbum.Contains(id)).ToList();
+            if (toAdd.Count == 0)
+                return Result.Success;
+
+            // Album track numbers are user-visible, so they start at 1.
+            var nextTrackNumber = (await database.AlbumHasTracks
+                .Where(link => link.AlbumId == request.AlbumId)
+                .MaxAsync(link => (int?)link.TrackNumber, cancellationToken) ?? 0) + 1;
+
+            foreach (var trackId in toAdd)
             {
-                AlbumId = request.AlbumId,
-                TrackId = trackId,
-                TrackNumber = nextTrackNumber++
-            }, cancellationToken);
+                await database.AlbumHasTracks.AddAsync(new AlbumHasTrack
+                {
+                    AlbumId = request.AlbumId,
+                    TrackId = trackId,
+                    TrackNumber = nextTrackNumber++
+                }, cancellationToken);
+            }
+
+            var saved = await database.TrySaveChangesAsync(
+                AppErrors.Conflict("Album.ConcurrentChange", "The album changed while adding tracks. Try again."), cancellationToken);
+            if (saved.IsError)
+                return saved;
+
+            logger.LogInformation("Added {Count} tracks to album {AlbumId}", toAdd.Count, request.AlbumId);
+
+            return Result.Success;
         }
-
-        var saved = await database.TrySaveChangesAsync(
-            AppErrors.Conflict("Album.ConcurrentChange", "The album changed while adding tracks. Try again."), cancellationToken);
-        if (saved.IsError)
-            return saved;
-
-        logger.LogInformation("Added {Count} tracks to album {AlbumId}", toAdd.Count, request.AlbumId);
-
-        return Result.Success;
     }
 }

backend/Core/Musify.Application/Albums/CreateAlbum.cs

@@ -12,61 +12,62 @@ using Musify.Application.Shared;
 using Musify.Domain.Entities;
 using Musify.Domain.ValueObjects;
 
-namespace Musify.Application.Albums;
-
-public record CreateAlbumCommand(
-    long UserId,
-    string Title,
-    string? Description,
-    int? ReleaseYear,
-    Guid PictureIntentId)
-    : ICommand<ErrorOr<AlbumApplicationResponse>>;
-
-public class CreateAlbumCommandHandler(
-    IEventBus eventBus,
-    IDatabase database,
-    UploadIntentValidator uploadIntentValidator,
-    ILogger<CreateAlbumCommandHandler> logger,
-    AlbumConfiguration albumConfiguration)
-    : ICommandHandler<CreateAlbumCommand, ErrorOr<AlbumApplicationResponse>>
+namespace Musify.Application.Albums
 {
-    public async ValueTask<ErrorOr<AlbumApplicationResponse>> Handle(CreateAlbumCommand request, CancellationToken cancellationToken)
+    public record CreateAlbumCommand(
+        long UserId,
+        string Title,
+        string? Description,
+        int? ReleaseYear,
+        Guid PictureIntentId)
+        : ICommand<ErrorOr<AlbumApplicationResponse>>;
+
+    public class CreateAlbumCommandHandler(
+        IEventBus eventBus,
+        IDatabase database,
+        UploadIntentValidator uploadIntentValidator,
+        ILogger<CreateAlbumCommandHandler> logger,
+        AlbumConfiguration albumConfiguration)
+        : ICommandHandler<CreateAlbumCommand, ErrorOr<AlbumApplicationResponse>>
     {
-        var userExists = await database.Users
-            .AsNoTracking()
-            .AnyAsync(user => user.Id == request.UserId, cancellationToken);
-        if (!userExists)
-            return AppErrors.NotFound("User", request.UserId);
-
-        var prepared = await PictureSourceChange.PrepareAsync(
-            uploadIntentValidator, request.PictureIntentId, request.UserId, UploadIntentPurpose.AlbumPicture, albumConfiguration, cancellationToken);
-        if (prepared.IsError)
-            return prepared.Errors;
-
-        var picture = prepared.Value;
-        var title = request.Title.Trim();
-
-        var album = new Album
+        public async ValueTask<ErrorOr<AlbumApplicationResponse>> Handle(CreateAlbumCommand request, CancellationToken cancellationToken)
         {
-            OwnerUserId = request.UserId,
-            Title = title,
-            NormalizedTitle = TextNormalizer.Normalize(title),
-            Description = request.Description,
-            ReleaseYear = request.ReleaseYear,
-            Pictures = picture.Pictures
-        };
+            var userExists = await database.Users
+                .AsNoTracking()
+                .AnyAsync(user => user.Id == request.UserId, cancellationToken);
+            if (!userExists)
+                return AppErrors.NotFound("User", request.UserId);
 
-        await database.Albums.AddAsync(album, cancellationToken);
+            var prepared = await PictureSourceChange.PrepareAsync(
+                uploadIntentValidator, request.PictureIntentId, request.UserId, UploadIntentPurpose.AlbumPicture, albumConfiguration, cancellationToken);
+            if (prepared.IsError)
+                return prepared.Errors;
 
-        await eventBus.PublishAsync(
-            new CreateAlbumResourcesEvent(
-                album.Id, picture.Intent.Id, picture.Intent.Bucket, picture.Intent.Key, picture.FinalKey, picture.Sizes),
-            cancellationToken);
+            var picture = prepared.Value;
+            var title = request.Title.Trim();
 
-        await database.SaveChangesAsync(cancellationToken);
+            var album = new Album
+            {
+                OwnerUserId = request.UserId,
+                Title = title,
+                NormalizedTitle = TextNormalizer.Normalize(title),
+                Description = request.Description,
+                ReleaseYear = request.ReleaseYear,
+                Pictures = picture.Pictures
+            };
 
-        logger.LogInformation("Created album {AlbumId} for user {UserId}", album.Id, request.UserId);
+            await database.Albums.AddAsync(album, cancellationToken);
 
-        return AlbumApplicationResponse.FromEntity(album, trackCount: 0);
+            await eventBus.PublishAsync(
+                new CreateAlbumResourcesEvent(
+                    album.Id, picture.Intent.Id, picture.Intent.Bucket, picture.Intent.Key, picture.FinalKey, picture.Sizes),
+                cancellationToken);
+
+            await database.SaveChangesAsync(cancellationToken);
+
+            logger.LogInformation("Created album {AlbumId} for user {UserId}", album.Id, request.UserId);
+
+            return AlbumApplicationResponse.FromEntity(album, trackCount: 0);
+        }
     }
 }

backend/Core/Musify.Application/Albums/DeleteAlbum.cs

@@ -6,31 +6,32 @@ using Musify.Application.Events;
 using Musify.Application.Shared;
 using Musify.Domain.ValueObjects;
 
-namespace Musify.Application.Albums;
-
-public record DeleteAlbumCommand(long UserId, Guid AlbumId)
-    : ICommand<ErrorOr<Success>>;
-
-public class DeleteAlbumCommandHandler(
-    IDatabase database,
-    IEventBus eventBus,
-    ILogger<DeleteAlbumCommandHandler> logger)
-    : ICommandHandler<DeleteAlbumCommand, ErrorOr<Success>>
+namespace Musify.Application.Albums
 {
-    public async ValueTask<ErrorOr<Success>> Handle(DeleteAlbumCommand request, CancellationToken cancellationToken)
+    public record DeleteAlbumCommand(long UserId, Guid AlbumId)
+        : ICommand<ErrorOr<Success>>;
+
+    public class DeleteAlbumCommandHandler(
+        IDatabase database,
+        IEventBus eventBus,
+        ILogger<DeleteAlbumCommandHandler> logger)
+        : ICommandHandler<DeleteAlbumCommand, ErrorOr<Success>>
     {
-        var found = await database.Albums.FindOwnedAsync(request.AlbumId, request.UserId, cancellationToken);
-        if (found.IsError)
-            return found.Errors;
+        public async ValueTask<ErrorOr<Success>> Handle(DeleteAlbumCommand request, CancellationToken cancellationToken)
+        {
+            var found = await database.Albums.FindOwnedAsync(request.AlbumId, request.UserId, cancellationToken);
+            if (found.IsError)
+                return found.Errors;
 
-        var album = found.Value;
-        album.LifeCycleStatus = LifeCycleStatus.Removing;
+            var album = found.Value;
+            album.LifeCycleStatus = LifeCycleStatus.Removing;
 
-        await eventBus.PublishAsync(new DeleteAlbumEvent(album.Id, request.UserId), cancellationToken);
-        await database.SaveChangesAsync(cancellationToken);
+            await eventBus.PublishAsync(new DeleteAlbumEvent(album.Id, request.UserId), cancellationToken);
+            await database.SaveChangesAsync(cancellationToken);
 
-        logger.LogInformation("Marked album {AlbumId} as removing", request.AlbumId);
+            logger.LogInformation("Marked album {AlbumId} as removing", request.AlbumId);
 
-        return Result.Success;
+            return Result.Success;
+        }
     }
 }

backend/Core/Musify.Application/Albums/GetAlbumById.cs

@@ -5,25 +5,26 @@ using Musify.Application.Albums.Responses;
 using Musify.Application.Contracts;
 using Musify.Application.Shared;
 
-namespace Musify.Application.Albums;
-
-public record GetAlbumByIdQuery(Guid Id)
-    : IQuery<ErrorOr<AlbumApplicationResponse>>;
-
-public class GetAlbumByIdQueryHandler(IDatabase database)
-    : IQueryHandler<GetAlbumByIdQuery, ErrorOr<AlbumApplicationResponse>>
+namespace Musify.Application.Albums
 {
-    public async ValueTask<ErrorOr<AlbumApplicationResponse>> Handle(GetAlbumByIdQuery request, CancellationToken cancellationToken)
-    {
-        var album = await database.Albums
-            .AsNoTracking()
-            .Active()
-            .Where(a => a.Id == request.Id)
-            .SelectResponse()
-            .SingleOrDefaultAsync(cancellationToken);
+    public record GetAlbumByIdQuery(Guid Id)
+        : IQuery<ErrorOr<AlbumApplicationResponse>>;
 
-        return album == null
-            ? AppErrors.NotFound("Album", request.Id)
-            : album;
+    public class GetAlbumByIdQueryHandler(IDatabase database)
+        : IQueryHandler<GetAlbumByIdQuery, ErrorOr<AlbumApplicationResponse>>
+    {
+        public async ValueTask<ErrorOr<AlbumApplicationResponse>> Handle(GetAlbumByIdQuery request, CancellationToken cancellationToken)
+        {
+            var album = await database.Albums
+                .AsNoTracking()
+                .Active()
+                .Where(a => a.Id == request.Id)
+                .SelectResponse()
+                .SingleOrDefaultAsync(cancellationToken);
+
+            return album == null
+                ? AppErrors.NotFound("Album", request.Id)
+                : album;
+        }
     }
 }

backend/Core/Musify.Application/Albums/GetAlbumTracks.cs

@@ -6,33 +6,34 @@ using Musify.Application.Contracts;
 using Musify.Application.Shared;
 using Musify.Application.Tracks.Responses;
 
-namespace Musify.Application.Albums;
-
-public record GetAlbumTracksQuery(
-    Guid AlbumId,
-    int PageNumber,
-    int PageSize)
-    : IQuery<ErrorOr<PaginatedResponse<TrackApplicationResponse>>>;
-
-public class GetAlbumTracksQueryHandler(IDatabase database)
-    : IQueryHandler<GetAlbumTracksQuery, ErrorOr<PaginatedResponse<TrackApplicationResponse>>>
+namespace Musify.Application.Albums
 {
-    public async ValueTask<ErrorOr<PaginatedResponse<TrackApplicationResponse>>> Handle(GetAlbumTracksQuery request, CancellationToken cancellationToken)
-    {
-        var albumExists = await database.Albums
-            .AsNoTracking()
-            .Active()
-            .AnyAsync(album => album.Id == request.AlbumId, cancellationToken);
-        if (!albumExists)
-            return AppErrors.NotFound("Album", request.AlbumId);
+    public record GetAlbumTracksQuery(
+        Guid AlbumId,
+        int PageNumber,
+        int PageSize)
+        : IQuery<ErrorOr<PaginatedResponse<TrackApplicationResponse>>>;
 
-        return await database.AlbumHasTracks
-            .AsNoTracking()
-            .Where(albumTrack => albumTrack.AlbumId == request.AlbumId && albumTrack.Track.LifeCycleStatus == Domain.ValueObjects.LifeCycleStatus.Active)
-            .OrderBy(albumTrack => albumTrack.TrackNumber)
-            .ThenBy(albumTrack => albumTrack.Id)
-            .Select(albumTrack => albumTrack.Track)
-            .SelectResponse()
-            .ToPaginatedAsync(new PageRequest(request.PageNumber, request.PageSize), cancellationToken);
+    public class GetAlbumTracksQueryHandler(IDatabase database)
+        : IQueryHandler<GetAlbumTracksQuery, ErrorOr<PaginatedResponse<TrackApplicationResponse>>>
+    {
+        public async ValueTask<ErrorOr<PaginatedResponse<TrackApplicationResponse>>> Handle(GetAlbumTracksQuery request, CancellationToken cancellationToken)
+        {
+            var albumExists = await database.Albums
+                .AsNoTracking()
+                .Active()
+                .AnyAsync(album => album.Id == request.AlbumId, cancellationToken);
+            if (!albumExists)
+                return AppErrors.NotFound("Album", request.AlbumId);
+
+            return await database.AlbumHasTracks
+                .AsNoTracking()
+                .Where(albumTrack => albumTrack.AlbumId == request.AlbumId && albumTrack.Track.LifeCycleStatus == Domain.ValueObjects.LifeCycleStatus.Active)
+                .OrderBy(albumTrack => albumTrack.TrackNumber)
+                .ThenBy(albumTrack => albumTrack.Id)
+                .Select(albumTrack => albumTrack.Track)
+                .SelectResponse()
+                .ToPaginatedAsync(new PageRequest(request.PageNumber, request.PageSize), cancellationToken);
+        }
     }
 }

backend/Core/Musify.Application/Albums/GetAlbums.cs

@@ -4,30 +4,31 @@ using Musify.Application.Albums.Responses;
 using Musify.Application.Contracts;
 using Musify.Application.Shared;
 
-namespace Musify.Application.Albums;
-
-public record GetAlbumsQuery(string? Title, int PageNumber, int PageSize)
-    : IQuery<PaginatedResponse<AlbumApplicationResponse>>;
-
-public class GetAlbumsQueryHandler(IDatabase database)
-    : IQueryHandler<GetAlbumsQuery, PaginatedResponse<AlbumApplicationResponse>>
+namespace Musify.Application.Albums
 {
-    public async ValueTask<PaginatedResponse<AlbumApplicationResponse>> Handle(GetAlbumsQuery request, CancellationToken cancellationToken)
+    public record GetAlbumsQuery(string? Title, int PageNumber, int PageSize)
+        : IQuery<PaginatedResponse<AlbumApplicationResponse>>;
+
+    public class GetAlbumsQueryHandler(IDatabase database)
+        : IQueryHandler<GetAlbumsQuery, PaginatedResponse<AlbumApplicationResponse>>
     {
-        var albumsQuery = database.Albums
-            .AsNoTracking()
-            .Active();
-
-        if (!string.IsNullOrWhiteSpace(request.Title))
+        public async ValueTask<PaginatedResponse<AlbumApplicationResponse>> Handle(GetAlbumsQuery request, CancellationToken cancellationToken)
         {
-            var normalizedTitle = TextNormalizer.Normalize(request.Title);
-            albumsQuery = albumsQuery.Where(album => album.NormalizedTitle.Contains(normalizedTitle));
-        }
+            var albumsQuery = database.Albums
+                .AsNoTracking()
+                .Active();
 
-        return await albumsQuery
-            .OrderByDescending(album => album.CreatedAt)
-            .ThenBy(album => album.Id)
-            .SelectResponse()
-            .ToPaginatedAsync(new PageRequest(request.PageNumber, request.PageSize), cancellationToken);
+            if (!string.IsNullOrWhiteSpace(request.Title))
+            {
+                var normalizedTitle = TextNormalizer.Normalize(request.Title);
+                albumsQuery = albumsQuery.Where(album => album.NormalizedTitle.Contains(normalizedTitle));
+            }
+
+            return await albumsQuery
+                .OrderByDescending(album => album.CreatedAt)
+                .ThenBy(album => album.Id)
+                .SelectResponse()
+                .ToPaginatedAsync(new PageRequest(request.PageNumber, request.PageSize), cancellationToken);
+        }
     }
 }

backend/Core/Musify.Application/Albums/GetAlbumsByUserId.cs

@@ -5,29 +5,30 @@ using Musify.Application.Albums.Responses;
 using Musify.Application.Contracts;
 using Musify.Application.Shared;
 
-namespace Musify.Application.Albums;
-
-public record GetAlbumsByUserIdQuery(long UserId, int PageNumber, int PageSize)
-    : IQuery<ErrorOr<PaginatedResponse<AlbumApplicationResponse>>>;
-
-public class GetAlbumsByUserIdQueryHandler(IDatabase database)
-    : IQueryHandler<GetAlbumsByUserIdQuery, ErrorOr<PaginatedResponse<AlbumApplicationResponse>>>
+namespace Musify.Application.Albums
 {
-    public async ValueTask<ErrorOr<PaginatedResponse<AlbumApplicationResponse>>> Handle(GetAlbumsByUserIdQuery request, CancellationToken cancellationToken)
-    {
-        var userExists = await database.Users
-            .AsNoTracking()
-            .AnyAsync(user => user.Id == request.UserId, cancellationToken);
-        if (!userExists)
-            return AppErrors.NotFound("User", request.UserId);
+    public record GetAlbumsByUserIdQuery(long UserId, int PageNumber, int PageSize)
+        : IQuery<ErrorOr<PaginatedResponse<AlbumApplicationResponse>>>;
 
-        return await database.Albums
-            .AsNoTracking()
-            .Active()
-            .Where(album => album.OwnerUserId == request.UserId)
-            .OrderByDescending(album => album.CreatedAt)
-            .ThenBy(album => album.Id)
-            .SelectResponse()
-            .ToPaginatedAsync(new PageRequest(request.PageNumber, request.PageSize), cancellationToken);
+    public class GetAlbumsByUserIdQueryHandler(IDatabase database)
+        : IQueryHandler<GetAlbumsByUserIdQuery, ErrorOr<PaginatedResponse<AlbumApplicationResponse>>>
+    {
+        public async ValueTask<ErrorOr<PaginatedResponse<AlbumApplicationResponse>>> Handle(GetAlbumsByUserIdQuery request, CancellationToken cancellationToken)
+        {
+            var userExists = await database.Users
+                .AsNoTracking()
+                .AnyAsync(user => user.Id == request.UserId, cancellationToken);
+            if (!userExists)
+                return AppErrors.NotFound("User", request.UserId);
+
+            return await database.Albums
+                .AsNoTracking()
+                .Active()
+                .Where(album => album.OwnerUserId == request.UserId)
+                .OrderByDescending(album => album.CreatedAt)
+                .ThenBy(album => album.Id)
+                .SelectResponse()
+                .ToPaginatedAsync(new PageRequest(request.PageNumber, request.PageSize), cancellationToken);
+        }
     }
 }

backend/Core/Musify.Application/Albums/GetRecentlyListenedAlbums.cs

@@ -3,49 +3,50 @@ using Microsoft.EntityFrameworkCore;
 using Musify.Application.Albums.Responses;
 using Musify.Application.Contracts;
 
-namespace Musify.Application.Albums;
-
-public record GetRecentlyListenedAlbumsQuery(long UserId, int Limit)
-    : IQuery<IReadOnlyList<AlbumApplicationResponse>>;
-
-public class GetRecentlyListenedAlbumsQueryHandler(IDatabase database)
-    : IQueryHandler<GetRecentlyListenedAlbumsQuery, IReadOnlyList<AlbumApplicationResponse>>
+namespace Musify.Application.Albums
 {
-    public async ValueTask<IReadOnlyList<AlbumApplicationResponse>> Handle(GetRecentlyListenedAlbumsQuery request, CancellationToken cancellationToken)
+    public record GetRecentlyListenedAlbumsQuery(long UserId, int Limit)
+        : IQuery<IReadOnlyList<AlbumApplicationResponse>>;
+
+    public class GetRecentlyListenedAlbumsQueryHandler(IDatabase database)
+        : IQueryHandler<GetRecentlyListenedAlbumsQuery, IReadOnlyList<AlbumApplicationResponse>>
     {
-        var listens = database.ListeningHistories
-            .AsNoTracking()
-            .Where(history => history.UserId == request.UserId && history.IsCounted);
+        public async ValueTask<IReadOnlyList<AlbumApplicationResponse>> Handle(GetRecentlyListenedAlbumsQuery request, CancellationToken cancellationToken)
+        {
+            var listens = database.ListeningHistories
+                .AsNoTracking()
+                .Where(history => history.UserId == request.UserId && history.IsCounted);
 
-        var ranked = await database.AlbumHasTracks
-            .AsNoTracking()
-            .Where(albumTrack => albumTrack.Album.LifeCycleStatus == Domain.ValueObjects.LifeCycleStatus.Active)
-            .Join(
-                listens,
-                albumTrack => albumTrack.TrackId,
-                history => history.TrackId,
-                (albumTrack, history) => new { albumTrack.AlbumId, history.ListenedAt })
-            .GroupBy(entry => entry.AlbumId)
-            .Select(group => new { AlbumId = group.Key, LastListenedAt = group.Max(entry => entry.ListenedAt) })
-            .OrderByDescending(entry => entry.LastListenedAt)
-            .ThenBy(entry => entry.AlbumId)
-            .Take(request.Limit)
-            .ToListAsync(cancellationToken);
+            var ranked = await database.AlbumHasTracks
+                .AsNoTracking()
+                .Where(albumTrack => albumTrack.Album.LifeCycleStatus == Domain.ValueObjects.LifeCycleStatus.Active)
+                .Join(
+                    listens,
+                    albumTrack => albumTrack.TrackId,
+                    history => history.TrackId,
+                    (albumTrack, history) => new { albumTrack.AlbumId, history.ListenedAt })
+                .GroupBy(entry => entry.AlbumId)
+                .Select(group => new { AlbumId = group.Key, LastListenedAt = group.Max(entry => entry.ListenedAt) })
+                .OrderByDescending(entry => entry.LastListenedAt)
+                .ThenBy(entry => entry.AlbumId)
+                .Take(request.Limit)
+                .ToListAsync(cancellationToken);
 
-        if (ranked.Count == 0)
-            return [];
+            if (ranked.Count == 0)
+                return [];
 
-        var albumIds = ranked.Select(entry => entry.AlbumId).ToList();
+            var albumIds = ranked.Select(entry => entry.AlbumId).ToList();
 
-        var albumsById = await database.Albums
-            .AsNoTracking()
-            .Where(album => albumIds.Contains(album.Id))
-            .SelectResponse()
-            .ToDictionaryAsync(album => album.Id, cancellationToken);
+            var albumsById = await database.Albums
+                .AsNoTracking()
+                .Where(album => albumIds.Contains(album.Id))
+                .SelectResponse()
+                .ToDictionaryAsync(album => album.Id, cancellationToken);
 
-        return ranked
-            .Where(entry => albumsById.ContainsKey(entry.AlbumId))
-            .Select(entry => albumsById[entry.AlbumId])
-            .ToList();
+            return ranked
+                .Where(entry => albumsById.ContainsKey(entry.AlbumId))
+                .Select(entry => albumsById[entry.AlbumId])
+                .ToList();
+        }
     }
 }

backend/Core/Musify.Application/Albums/RemoveTrackFromAlbum.cs

@@ -5,41 +5,42 @@ using Microsoft.Extensions.Logging;
 using Musify.Application.Contracts;
 using Musify.Application.Shared;
 
-namespace Musify.Application.Albums;
-
-public record RemoveTrackFromAlbumCommand(long UserId, Guid AlbumId, Guid TrackId)
-    : ICommand<ErrorOr<Success>>;
-
-public class RemoveTrackFromAlbumCommandHandler(
-    IDatabase database,
-    ILogger<RemoveTrackFromAlbumCommandHandler> logger)
-    : ICommandHandler<RemoveTrackFromAlbumCommand, ErrorOr<Success>>
+namespace Musify.Application.Albums
 {
-    public async ValueTask<ErrorOr<Success>> Handle(RemoveTrackFromAlbumCommand request, CancellationToken cancellationToken)
+    public record RemoveTrackFromAlbumCommand(long UserId, Guid AlbumId, Guid TrackId)
+        : ICommand<ErrorOr<Success>>;
+
+    public class RemoveTrackFromAlbumCommandHandler(
+        IDatabase database,
+        ILogger<RemoveTrackFromAlbumCommandHandler> logger)
+        : ICommandHandler<RemoveTrackFromAlbumCommand, ErrorOr<Success>>
     {
-        var album = await database.Albums.FindOwnedAsync(request.AlbumId, request.UserId, cancellationToken);
-        if (album.IsError)
-            return album.Errors;
+        public async ValueTask<ErrorOr<Success>> Handle(RemoveTrackFromAlbumCommand request, CancellationToken cancellationToken)
+        {
+            var album = await database.Albums.FindOwnedAsync(request.AlbumId, request.UserId, cancellationToken);
+            if (album.IsError)
+                return album.Errors;
 
-        var albumTracks = await database.AlbumHasTracks
-            .Where(albumTrack => albumTrack.AlbumId == request.AlbumId)
-            .OrderBy(albumTrack => albumTrack.TrackNumber)
-            .ToListAsync(cancellationToken);
+            var albumTracks = await database.AlbumHasTracks
+                .Where(albumTrack => albumTrack.AlbumId == request.AlbumId)
+                .OrderBy(albumTrack => albumTrack.TrackNumber)
+                .ToListAsync(cancellationToken);
 
-        var link = albumTracks.SingleOrDefault(albumTrack => albumTrack.TrackId == request.TrackId);
-        if (link == null)
-            return Error.NotFound("Album.TrackNotFound", "Track is not in the album.");
+            var link = albumTracks.SingleOrDefault(albumTrack => albumTrack.TrackId == request.TrackId);
+            if (link == null)
+                return Error.NotFound("Album.TrackNotFound", "Track is not in the album.");
 
-        database.AlbumHasTracks.Remove(link);
+            database.AlbumHasTracks.Remove(link);
 
-        var trackNumber = 1;
-        foreach (var remaining in albumTracks.Where(albumTrack => albumTrack.Id != link.Id))
-            remaining.TrackNumber = trackNumber++;
+            var trackNumber = 1;
+            foreach (var remaining in albumTracks.Where(albumTrack => albumTrack.Id != link.Id))
+                remaining.TrackNumber = trackNumber++;
 
-        await database.SaveChangesAsync(cancellationToken);
+            await database.SaveChangesAsync(cancellationToken);
 
-        logger.LogInformation("Removed track {TrackId} from album {AlbumId}", request.TrackId, request.AlbumId);
+            logger.LogInformation("Removed track {TrackId} from album {AlbumId}", request.TrackId, request.AlbumId);
 
-        return Result.Success;
+            return Result.Success;
+        }
     }
 }

backend/Core/Musify.Application/Albums/RequestAlbumPictureUpload.cs

@@ -5,20 +5,21 @@ using Musify.Application.Pictures.Responses;
 using Musify.Application.Services;
 using Musify.Domain.ValueObjects;
 
-namespace Musify.Application.Albums;
-
-public record RequestAlbumPictureUploadCommand(
-    long UserId,
-    string FileType,
-    string ContentType,
-    long? ExpectedSizeBytes = null)
-    : ICommand<ErrorOr<PictureUploadResponse>>;
-
-public class RequestAlbumPictureUploadCommandHandler(UploadIntentIssuer issuer, AlbumConfiguration albumConfiguration)
-    : ICommandHandler<RequestAlbumPictureUploadCommand, ErrorOr<PictureUploadResponse>>
+namespace Musify.Application.Albums
 {
-    public async ValueTask<ErrorOr<PictureUploadResponse>> Handle(RequestAlbumPictureUploadCommand request, CancellationToken cancellationToken) =>
-        await issuer.IssuePictureAsync(
-            request.UserId, UploadIntentPurpose.AlbumPicture, albumConfiguration,
-            request.FileType, request.ContentType, request.ExpectedSizeBytes, cancellationToken);
+    public record RequestAlbumPictureUploadCommand(
+        long UserId,
+        string FileType,
+        string ContentType,
+        long? ExpectedSizeBytes = null)
+        : ICommand<ErrorOr<PictureUploadResponse>>;
+
+    public class RequestAlbumPictureUploadCommandHandler(UploadIntentIssuer issuer, AlbumConfiguration albumConfiguration)
+        : ICommandHandler<RequestAlbumPictureUploadCommand, ErrorOr<PictureUploadResponse>>
+    {
+        public async ValueTask<ErrorOr<PictureUploadResponse>> Handle(RequestAlbumPictureUploadCommand request, CancellationToken cancellationToken) =>
+            await issuer.IssuePictureAsync(
+                request.UserId, UploadIntentPurpose.AlbumPicture, albumConfiguration,
+                request.FileType, request.ContentType, request.ExpectedSizeBytes, cancellationToken);
+    }
 }

backend/Core/Musify.Application/Albums/Responses/AlbumApplicationResponse.cs

@@ -1,40 +1,41 @@
 using Musify.Domain.Entities;
 
-namespace Musify.Application.Albums.Responses;
-
-public record AlbumApplicationResponse(
-    Guid Id,
-    string Title,
-    string? Description,
-    int? ReleaseYear,
-    long OwnerUserId,
-    int TrackCount,
-    string? SmallImageKeyName,
-    string? MediumImageKeyName,
-    string? LargeImageKeyName,
-    DateTime CreatedAt,
-    DateTime UpdatedAt,
-    IReadOnlyList<Guid> CoverTrackIds)
+namespace Musify.Application.Albums.Responses
 {
-    public const int CoverTrackCount = AlbumProjections.CoverTrackCount;
-
-    public static AlbumApplicationResponse FromEntity(
-        Album album,
-        int trackCount,
-        IReadOnlyList<Guid>? coverTrackIds = null)
+    public record AlbumApplicationResponse(
+        Guid Id,
+        string Title,
+        string? Description,
+        int? ReleaseYear,
+        long OwnerUserId,
+        int TrackCount,
+        string? SmallImageKeyName,
+        string? MediumImageKeyName,
+        string? LargeImageKeyName,
+        DateTime CreatedAt,
+        DateTime UpdatedAt,
+        IReadOnlyList<Guid> CoverTrackIds)
     {
-        return new AlbumApplicationResponse(
-            album.Id,
-            album.Title,
-            album.Description,
-            album.ReleaseYear,
-            album.OwnerUserId,
-            trackCount,
-            album.Pictures?.SmallName,
-            album.Pictures?.MediumName,
-            album.Pictures?.LargeName,
-            album.CreatedAt,
-            album.UpdatedAt,
-            coverTrackIds ?? []);
+        public const int CoverTrackCount = AlbumProjections.CoverTrackCount;
+
+        public static AlbumApplicationResponse FromEntity(
+            Album album,
+            int trackCount,
+            IReadOnlyList<Guid>? coverTrackIds = null)
+        {
+            return new AlbumApplicationResponse(
+                album.Id,
+                album.Title,
+                album.Description,
+                album.ReleaseYear,
+                album.OwnerUserId,
+                trackCount,
+                album.Pictures?.SmallName,
+                album.Pictures?.MediumName,
+                album.Pictures?.LargeName,
+                album.CreatedAt,
+                album.UpdatedAt,
+                coverTrackIds ?? []);
+        }
     }
 }

backend/Core/Musify.Application/Albums/Responses/AlbumProjections.cs

@@ -1,31 +1,32 @@
 using Musify.Domain.Entities;
 using Musify.Domain.ValueObjects;
 
-namespace Musify.Application.Albums.Responses;
-
-public static class AlbumProjections
+namespace Musify.Application.Albums.Responses
 {
-    public const int CoverTrackCount = 4;
+    public static class AlbumProjections
+    {
+        public const int CoverTrackCount = 4;
 
-    public static IQueryable<Album> Active(this IQueryable<Album> query) =>
-        query.Where(album => album.LifeCycleStatus == LifeCycleStatus.Active);
+        public static IQueryable<Album> Active(this IQueryable<Album> query) =>
+            query.Where(album => album.LifeCycleStatus == LifeCycleStatus.Active);
 
-    public static IQueryable<AlbumApplicationResponse> SelectResponse(this IQueryable<Album> query) =>
-        query.Select(album => new AlbumApplicationResponse(
-            album.Id,
-            album.Title,
-            album.Description,
-            album.ReleaseYear,
-            album.OwnerUserId,
-            album.AlbumTracks.Count,
-            album.Pictures!.SmallName,
-            album.Pictures!.MediumName,
-            album.Pictures!.LargeName,
-            album.CreatedAt,
-            album.UpdatedAt,
-            album.AlbumTracks
-                .OrderBy(albumTrack => albumTrack.TrackNumber)
-                .Take(CoverTrackCount)
-                .Select(albumTrack => albumTrack.TrackId)
-                .ToList()));
+        public static IQueryable<AlbumApplicationResponse> SelectResponse(this IQueryable<Album> query) =>
+            query.Select(album => new AlbumApplicationResponse(
+                album.Id,
+                album.Title,
+                album.Description,
+                album.ReleaseYear,
+                album.OwnerUserId,
+                album.AlbumTracks.Count,
+                album.Pictures!.SmallName,
+                album.Pictures!.MediumName,
+                album.Pictures!.LargeName,
+                album.CreatedAt,
+                album.UpdatedAt,
+                album.AlbumTracks
+                    .OrderBy(albumTrack => albumTrack.TrackNumber)
+                    .Take(CoverTrackCount)
+                    .Select(albumTrack => albumTrack.TrackId)
+                    .ToList()));
+    }
 }

backend/Core/Musify.Application/Albums/UpdateAlbum.cs

@@ -11,63 +11,64 @@ using Musify.Application.Services;
 using Musify.Application.Shared;
 using Musify.Domain.ValueObjects;
 
-namespace Musify.Application.Albums;
-
-public record UpdateAlbumCommand(
-    long UserId,
-    Guid AlbumId,
-    string Title,
-    string? Description,
-    int? ReleaseYear,
-    Guid? NewPictureIntentId)
-    : ICommand<ErrorOr<AlbumApplicationResponse>>;
-
-public class UpdateAlbumCommandHandler(
-    IEventBus eventBus,
-    IDatabase database,
-    UploadIntentValidator uploadIntentValidator,
-    ILogger<UpdateAlbumCommandHandler> logger,
-    AlbumConfiguration albumConfiguration)
-    : ICommandHandler<UpdateAlbumCommand, ErrorOr<AlbumApplicationResponse>>
+namespace Musify.Application.Albums
 {
-    public async ValueTask<ErrorOr<AlbumApplicationResponse>> Handle(UpdateAlbumCommand request, CancellationToken cancellationToken)
+    public record UpdateAlbumCommand(
+        long UserId,
+        Guid AlbumId,
+        string Title,
+        string? Description,
+        int? ReleaseYear,
+        Guid? NewPictureIntentId)
+        : ICommand<ErrorOr<AlbumApplicationResponse>>;
+
+    public class UpdateAlbumCommandHandler(
+        IEventBus eventBus,
+        IDatabase database,
+        UploadIntentValidator uploadIntentValidator,
+        ILogger<UpdateAlbumCommandHandler> logger,
+        AlbumConfiguration albumConfiguration)
+        : ICommandHandler<UpdateAlbumCommand, ErrorOr<AlbumApplicationResponse>>
     {
-        var found = await database.Albums.FindOwnedAsync(request.AlbumId, request.UserId, cancellationToken);
-        if (found.IsError)
-            return found.Errors;
-
-        var album = found.Value;
-        var title = request.Title.Trim();
-
-        album.Title = title;
-        album.NormalizedTitle = TextNormalizer.Normalize(title);
-        album.Description = request.Description;
-        album.ReleaseYear = request.ReleaseYear;
-
-        if (request.NewPictureIntentId is { } intentId)
+        public async ValueTask<ErrorOr<AlbumApplicationResponse>> Handle(UpdateAlbumCommand request, CancellationToken cancellationToken)
         {
-            var prepared = await PictureSourceChange.PrepareAsync(
-                uploadIntentValidator, intentId, request.UserId, UploadIntentPurpose.AlbumPicture, albumConfiguration, cancellationToken);
-            if (prepared.IsError)
-                return prepared.Errors;
+            var found = await database.Albums.FindOwnedAsync(request.AlbumId, request.UserId, cancellationToken);
+            if (found.IsError)
+                return found.Errors;
 
-            var picture = prepared.Value;
-            album.Pictures = picture.Pictures;
+            var album = found.Value;
+            var title = request.Title.Trim();
 
-            await eventBus.PublishAsync(
-                new UpdateAlbumPictureSourceEvent(
-                    album.Id, picture.Intent.Id, picture.Intent.Bucket, picture.Intent.Key, picture.FinalKey, picture.Sizes),
-                cancellationToken);
+            album.Title = title;
+            album.NormalizedTitle = TextNormalizer.Normalize(title);
+            album.Description = request.Description;
+            album.ReleaseYear = request.ReleaseYear;
+
+            if (request.NewPictureIntentId is { } intentId)
+            {
+                var prepared = await PictureSourceChange.PrepareAsync(
+                    uploadIntentValidator, intentId, request.UserId, UploadIntentPurpose.AlbumPicture, albumConfiguration, cancellationToken);
+                if (prepared.IsError)
+                    return prepared.Errors;
+
+                var picture = prepared.Value;
+                album.Pictures = picture.Pictures;
+
+                await eventBus.PublishAsync(
+                    new UpdateAlbumPictureSourceEvent(
+                        album.Id, picture.Intent.Id, picture.Intent.Bucket, picture.Intent.Key, picture.FinalKey, picture.Sizes),
+                    cancellationToken);
+            }
+
+            await database.SaveChangesAsync(cancellationToken);
+
+            logger.LogInformation("Updated album {AlbumId}", album.Id);
+
+            return await database.Albums
+                .AsNoTracking()
+                .Where(a => a.Id == album.Id)
+                .SelectResponse()
+                .SingleAsync(cancellationToken);
         }
-
-        await database.SaveChangesAsync(cancellationToken);
-
-        logger.LogInformation("Updated album {AlbumId}", album.Id);
-
-        return await database.Albums
-            .AsNoTracking()
-            .Where(a => a.Id == album.Id)
-            .SelectResponse()
-            .SingleAsync(cancellationToken);
     }
 }