Point the IDE dev settings at the shared Infrastructure stack

appsettings.Development.json still targeted Musify's old own Postgres
(port 59000) with the superuser, the default RabbitMQ vhost as guest and
the admin S3 keys. They now use Infrastructure's dev ports and Musify's
own dev credentials (role, vhost and S3 identity), the same defaults as
deploy/.env.example.

The API's non-secret Zitadel settings (issuer, metadata, endpoints) move
there too, so user-secrets only need the per-machine client id.

backend/.editorconfig

@@ -1,65 +0,0 @@
-root = true
-
-[*]
-charset = utf-8
-insert_final_newline = true
-trim_trailing_whitespace = true
-indent_style = space
-
-[*.{csproj,props,targets,slnx,xml}]
-indent_size = 2
-
-[*.json]
-indent_size = 4
-
-[**/Migrations/**.cs]
-generated_code = true
-
-[*.cs]
-indent_size = 4
-
-csharp_style_namespace_declarations = file_scoped:warning
-csharp_using_directive_placement = outside_namespace:warning
-dotnet_sort_system_directives_first = true
-dotnet_separate_import_directive_groups = false
-dotnet_diagnostic.IDE0005.severity = warning
-
-dotnet_style_require_accessibility_modifiers = always:warning
-csharp_style_var_for_built_in_types = true:suggestion
-csharp_style_var_when_type_is_apparent = true:suggestion
-csharp_style_var_elsewhere = true:suggestion
-csharp_prefer_braces = when_multiline:warning
-csharp_style_prefer_primary_constructors = true:suggestion
-csharp_style_expression_bodied_methods = when_on_single_line:suggestion
-dotnet_style_prefer_collection_expression = when_types_loosely_match:suggestion
-
-dotnet_naming_rule.private_fields.symbols = private_fields
-dotnet_naming_rule.private_fields.style = camel_case
-dotnet_naming_rule.private_fields.severity = warning
-dotnet_naming_symbols.private_fields.applicable_kinds = field
-dotnet_naming_symbols.private_fields.applicable_accessibilities = private
-dotnet_naming_symbols.private_fields.required_modifiers =
-dotnet_naming_style.camel_case.capitalization = camel_case
-
-dotnet_naming_rule.private_constants.symbols = private_constants
-dotnet_naming_rule.private_constants.style = pascal_case
-dotnet_naming_rule.private_constants.severity = warning
-dotnet_naming_symbols.private_constants.applicable_kinds = field
-dotnet_naming_symbols.private_constants.required_modifiers = const
-dotnet_naming_style.pascal_case.capitalization = pascal_case
-
-# Analyzer rules that would need behaviour or API changes; downgraded in P0, revisit in P15.
-dotnet_diagnostic.CA1848.severity = suggestion
-dotnet_diagnostic.CA1873.severity = suggestion
-dotnet_diagnostic.CA1305.severity = suggestion
-dotnet_diagnostic.CA1707.severity = suggestion
-dotnet_diagnostic.CA1859.severity = suggestion
-dotnet_diagnostic.CA1716.severity = suggestion
-dotnet_diagnostic.CA1000.severity = suggestion
-dotnet_diagnostic.CA1725.severity = suggestion
-dotnet_diagnostic.CA1816.severity = suggestion
-dotnet_diagnostic.CA1822.severity = suggestion
-dotnet_diagnostic.CA1852.severity = suggestion
-dotnet_diagnostic.CA1068.severity = suggestion
-dotnet_diagnostic.CA1711.severity = suggestion
-dotnet_diagnostic.CA1861.severity = suggestion

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

@@ -0,0 +1,82 @@
+using ErrorOr;
+using Mediator;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Logging;
+using Musify.Application.Contracts;
+using Musify.Domain.Entities;
+
+namespace Musify.Application.Albums
+{
+    public record AddTrackToAlbumCommand(long UserId, Guid AlbumId, Guid TrackId)
+        : ICommand<ErrorOr<Success>>;
+
+    public class AddTrackToAlbumCommandHandler(
+        IDatabase database,
+        ILogger<AddTrackToAlbumCommandHandler> logger)
+        : ICommandHandler<AddTrackToAlbumCommand, ErrorOr<Success>>
+    {
+        public async ValueTask<ErrorOr<Success>> Handle(AddTrackToAlbumCommand request, CancellationToken cancellationToken)
+        {
+            var album = await database.Albums
+                .AsNoTracking()
+                .SingleOrDefaultAsync(a => a.Id == request.AlbumId, cancellationToken);
+            if (album == null)
+            {
+                logger.LogInformation("Album {AlbumId} not found", request.AlbumId);
+                return Error.NotFound();
+            }
+
+            if (album.OwnerUserId != request.UserId)
+            {
+                logger.LogWarning("User {UserId} is not the owner of album {AlbumId}", request.UserId, request.AlbumId);
+                return Error.Unauthorized();
+            }
+
+            var track = await database.Tracks
+                .AsNoTracking()
+                .SingleOrDefaultAsync(t => t.Id == request.TrackId, cancellationToken);
+            if (track == null)
+            {
+                logger.LogInformation("Track {TrackId} not found", request.TrackId);
+                return Error.NotFound(description: $"Track {request.TrackId} not found");
+            }
+
+            if (track.OwnerUserId != request.UserId)
+            {
+                logger.LogWarning("User {UserId} does not own track {TrackId}", request.UserId, request.TrackId);
+                return Error.Unauthorized();
+            }
+
+            var alreadyAdded = await database.AlbumHasTracks
+                .AsNoTracking()
+                .AnyAsync(albumTrack => albumTrack.AlbumId == request.AlbumId && albumTrack.TrackId == request.TrackId, cancellationToken);
+            if (alreadyAdded)
+            {
+                logger.LogInformation("Track {TrackId} already in album {AlbumId}", request.TrackId, request.AlbumId);
+                return Error.Conflict(description: "Track is already in the album.");
+            }
+
+            var albumTracksQuery = database.AlbumHasTracks
+                .Where(albumTrack => albumTrack.AlbumId == request.AlbumId);
+
+            var hasTracks = await albumTracksQuery.AnyAsync(cancellationToken);
+            var nextTrackNumber = hasTracks
+                ? await albumTracksQuery.MaxAsync(albumTrack => albumTrack.TrackNumber, cancellationToken) + 1
+                : 1;
+
+            await database.AlbumHasTracks.AddAsync(new AlbumHasTrack
+            {
+                AlbumId = request.AlbumId,
+                TrackId = request.TrackId,
+                TrackNumber = nextTrackNumber
+            }, cancellationToken);
+
+            await database.SaveChangesAsync(cancellationToken);
+
+            logger.LogInformation("Added track {TrackId} to album {AlbumId} as number {TrackNumber}",
+                request.TrackId, request.AlbumId, nextTrackNumber);
+
+            return new Success();
+        }
+    }
+}

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

@@ -1,77 +0,0 @@
-using ErrorOr;
-using Mediator;
-using Microsoft.EntityFrameworkCore;
-using Microsoft.Extensions.Logging;
-using Musify.Application.Contracts;
-using Musify.Application.Shared;
-using Musify.Domain.Entities;
-using Musify.Domain.ValueObjects;
-
-namespace Musify.Application.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>>
-{
-    public async ValueTask<ErrorOr<Success>> Handle(AddTracksToAlbumCommand request, CancellationToken cancellationToken)
-    {
-        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)
-        {
-            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;
-    }
-}

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

@@ -2,71 +2,127 @@ using ErrorOr;
 using Mediator;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.Logging;
-using Musify.Application.Albums.Responses;
 using Musify.Application.Configuration;
-using Musify.Application.Contracts;
-using Musify.Application.Events;
-using Musify.Application.Pictures;
-using Musify.Application.Services;
 using Musify.Application.Shared;
+using Musify.Application.Events;
+using Musify.Application.Albums.Responses;
+using Musify.Application.Services;
 using Musify.Domain.Entities;
 using Musify.Domain.ValueObjects;
+using Musify.Application.Contracts;
 
-namespace Musify.Application.Albums;
+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>>
 {
-    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,
+        ApplicationStorageConfiguration storageConfiguration,
+        AlbumConfiguration albumConfiguration,
+        UploadIntentConfiguration uploadIntentConfiguration)
+        : ICommandHandler<CreateAlbumCommand, ErrorOr<AlbumApplicationResponse>>
     {
-        var userExists = await database.Users
+        public async ValueTask<ErrorOr<AlbumApplicationResponse>> Handle(CreateAlbumCommand request, CancellationToken cancellationToken)
-            .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
         {
-            OwnerUserId = request.UserId,
+            var userExists = await database.Users
-            Title = title,
+                .AsNoTracking()
-            NormalizedTitle = TextNormalizer.Normalize(title),
+                .AnyAsync(user => user.Id == request.UserId, cancellationToken);
-            Description = request.Description,
+            if (!userExists)
-            ReleaseYear = request.ReleaseYear,
+            {
-            Pictures = picture.Pictures
+                logger.LogWarning("User {UserId} not found", request.UserId);
-        };
+                return Error.NotFound(description: $"User {request.UserId} not found");
+            }
 
-        await database.Albums.AddAsync(album, cancellationToken);
+            var pictureIntent = await uploadIntentValidator.ValidateAndLoadAsync(
+                uploadIntentConfiguration, request.PictureIntentId, request.UserId, cancellationToken);
+            if (pictureIntent.IsError)
+                return pictureIntent.Errors;
 
-        await eventBus.PublishAsync(
+            var intent = pictureIntent.Value;
-            new CreateAlbumResourcesEvent(
+            var title = request.Title.Trim();
-                album.Id, picture.Intent.Id, picture.Intent.Bucket, picture.Intent.Key, picture.FinalKey, picture.Sizes),
-            cancellationToken);
 
-        await database.SaveChangesAsync(cancellationToken);
+            var album = new Album
+            {
+                OwnerUserId = request.UserId,
+                Title = title,
+                NormalizedTitle = title.ToUpperInvariant(),
+                Description = request.Description,
+                ReleaseYear = request.ReleaseYear,
+                Pictures = new AlbumPictures
+                {
+                    OriginalName = intent.ObjectName,
+                    SmallName = intent.ObjectName,
+                    MediumName = intent.ObjectName,
+                    LargeName = intent.ObjectName
+                }
+            };
 
-        logger.LogInformation("Created album {AlbumId} for user {UserId}", album.Id, request.UserId);
+            await database.Albums.AddAsync(album, cancellationToken);
 
-        return AlbumApplicationResponse.FromEntity(album, trackCount: 0);
+            var finalPictureKey = albumConfiguration.Routes.BuildOriginalPicturePath(request.UserId, intent.ObjectName);
+            var publishResult = await PublishCreateAlbumEventAsync(album.Id, intent, finalPictureKey, cancellationToken);
+            if (publishResult.IsError)
+                return publishResult.Errors;
+
+            try
+            {
+                await database.SaveChangesAsync(cancellationToken);
+            }
+            catch (Exception exception)
+            {
+                logger.LogError(exception, "Failed to save album for user {UserId}", request.UserId);
+                return Error.Failure(description: $"Failed to create album for user {request.UserId}");
+            }
+
+            logger.LogInformation("Created album {AlbumId} for user {UserId}", album.Id, request.UserId);
+
+            return AlbumApplicationResponse.FromEntity(album, trackCount: 0);
+        }
+
+        private async Task<ErrorOr<Success>> PublishCreateAlbumEventAsync(
+            Guid albumId,
+            UploadIntent pictureIntent,
+            string finalPictureKey,
+            CancellationToken cancellationToken)
+        {
+            try
+            {
+                await eventBus.PublishAsync(
+                    new CreateAlbumResourcesEvent(
+                        albumId,
+                        pictureIntent.Id,
+                        storageConfiguration.Bucket,
+                        pictureIntent.Key,
+                        finalPictureKey,
+                        new ImageSize(
+                            albumConfiguration.Routes.SmallPicturesPath,
+                            albumConfiguration.PicturesSizes.SmallPictureWidth,
+                            albumConfiguration.PicturesSizes.SmallPictureHeight),
+                        new ImageSize(
+                            albumConfiguration.Routes.MediumPicturesPath,
+                            albumConfiguration.PicturesSizes.MediumPictureWidth,
+                            albumConfiguration.PicturesSizes.MediumPictureHeight),
+                        new ImageSize(
+                            albumConfiguration.Routes.LargePicturesPath,
+                            albumConfiguration.PicturesSizes.LargePictureWidth,
+                            albumConfiguration.PicturesSizes.LargePictureHeight)),
+                    cancellationToken);
+                return new Success();
+            }
+            catch (Exception exception)
+            {
+                logger.LogError(exception, "Failed to publish create album event for album {AlbumId}", albumId);
+                return Error.Failure(description: $"Failed to publish create album event for album {albumId}");
+            }
+        }
     }
 }

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

@@ -1,36 +1,50 @@
 using ErrorOr;
 using Mediator;
+using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.Logging;
 using Musify.Application.Contracts;
-using Musify.Application.Events;
-using Musify.Application.Shared;
-using Musify.Domain.ValueObjects;
 
-namespace Musify.Application.Albums;
+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>>
 {
-    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,
+        ILogger<DeleteAlbumCommandHandler> logger)
+        : ICommandHandler<DeleteAlbumCommand, ErrorOr<Success>>
     {
-        var found = await database.Albums.FindOwnedAsync(request.AlbumId, request.UserId, cancellationToken);
+        public async ValueTask<ErrorOr<Success>> Handle(DeleteAlbumCommand request, CancellationToken cancellationToken)
-        if (found.IsError)
+        {
-            return found.Errors;
+            var album = await database.Albums
+                .SingleOrDefaultAsync(a => a.Id == request.AlbumId, cancellationToken);
+            if (album == null)
+            {
+                logger.LogDebug("Album {AlbumId} not found", request.AlbumId);
+                return Error.NotFound();
+            }
 
-        var album = found.Value;
+            if (album.OwnerUserId != request.UserId)
-        album.LifeCycleStatus = LifeCycleStatus.Removing;
+            {
+                logger.LogWarning("Album {AlbumId} does not belong to user {UserId}", request.AlbumId, request.UserId);
+                return Error.Unauthorized();
+            }
 
-        await eventBus.PublishAsync(new DeleteAlbumEvent(album.Id, request.UserId), cancellationToken);
+            database.Albums.Remove(album);
-        await database.SaveChangesAsync(cancellationToken);
 
-        logger.LogInformation("Marked album {AlbumId} as removing", request.AlbumId);
+            try
+            {
+                await database.SaveChangesAsync(cancellationToken);
+            }
+            catch (Exception exception)
+            {
+                logger.LogError(exception, "Failed to delete album {AlbumId}", request.AlbumId);
+                return Error.Failure(description: $"Failed to delete album {request.AlbumId}");
+            }
 
-        return Result.Success;
+            logger.LogInformation("Deleted album {AlbumId} for user {UserId}", request.AlbumId, request.UserId);
+
+            return new Success();
+        }
     }
 }

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

@@ -3,27 +3,36 @@ using Mediator;
 using Microsoft.EntityFrameworkCore;
 using Musify.Application.Albums.Responses;
 using Musify.Application.Contracts;
-using Musify.Application.Shared;
 
-namespace Musify.Application.Albums;
+namespace Musify.Application.Albums
-
-public record GetAlbumByIdQuery(Guid Id)
-    : IQuery<ErrorOr<AlbumApplicationResponse>>;
-
-public class GetAlbumByIdQueryHandler(IDatabase database)
-    : IQueryHandler<GetAlbumByIdQuery, ErrorOr<AlbumApplicationResponse>>
 {
-    public async ValueTask<ErrorOr<AlbumApplicationResponse>> Handle(GetAlbumByIdQuery request, CancellationToken cancellationToken)
+    public record GetAlbumByIdQuery(Guid Id)
-    {
+        : IQuery<ErrorOr<AlbumApplicationResponse>>;
-        var album = await database.Albums
-            .AsNoTracking()
-            .Active()
-            .Where(a => a.Id == request.Id)
-            .SelectResponse()
-            .SingleOrDefaultAsync(cancellationToken);
 
-        return album == null
+    public class GetAlbumByIdQueryHandler(IDatabase database)
-            ? AppErrors.NotFound("Album", request.Id)
+        : IQueryHandler<GetAlbumByIdQuery, ErrorOr<AlbumApplicationResponse>>
-            : album;
+    {
+        public async ValueTask<ErrorOr<AlbumApplicationResponse>> Handle(GetAlbumByIdQuery request, CancellationToken cancellationToken)
+        {
+            var album = await database.Albums
+                .AsNoTracking()
+                .Where(a => a.Id == request.Id)
+                .Select(a => new
+                {
+                    Album = a,
+                    TrackCount = a.AlbumTracks.Count,
+                    CoverTrackIds = a.AlbumTracks
+                        .OrderBy(albumTrack => albumTrack.TrackNumber)
+                        .Take(AlbumApplicationResponse.CoverTrackCount)
+                        .Select(albumTrack => albumTrack.TrackId)
+                        .ToList()
+                })
+                .SingleOrDefaultAsync(cancellationToken);
+
+            if (album == null)
+                return Error.NotFound();
+
+            return AlbumApplicationResponse.FromEntity(album.Album, album.TrackCount, album.CoverTrackIds);
+        }
     }
 }

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

@@ -0,0 +1,49 @@
+using ErrorOr;
+using Mediator;
+using Microsoft.EntityFrameworkCore;
+using MimeMapping;
+using Musify.Application.Configuration;
+using Musify.Application.Contracts;
+
+namespace Musify.Application.Albums
+{
+    public record GetAlbumCoverQuery(Guid AlbumId, string Size)
+        : IQuery<ErrorOr<AlbumCoverLocation>>;
+
+    public record AlbumCoverLocation(string Bucket, string Key, string ContentType);
+
+    public class GetAlbumCoverQueryHandler(
+        IDatabase database,
+        ApplicationStorageConfiguration storageConfiguration,
+        AlbumConfiguration albumConfiguration)
+        : IQueryHandler<GetAlbumCoverQuery, ErrorOr<AlbumCoverLocation>>
+    {
+        public async ValueTask<ErrorOr<AlbumCoverLocation>> Handle(GetAlbumCoverQuery request, CancellationToken cancellationToken)
+        {
+            var pictures = await database.Albums.AsNoTracking()
+                .Where(a => a.Id == request.AlbumId)
+                .Select(a => a.Pictures)
+                .SingleOrDefaultAsync(cancellationToken);
+
+            if (pictures == null)
+                return Error.NotFound();
+
+            var routes = albumConfiguration.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 AlbumCoverLocation(storageConfiguration.Bucket, key, contentType);
+        }
+
+        private static string? BuildKey(Func<string, string> builder, string? name)
+            => string.IsNullOrEmpty(name) ? null : builder(name);
+    }
+}

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

@@ -1,38 +1,49 @@
 using ErrorOr;
 using Mediator;
 using Microsoft.EntityFrameworkCore;
-using Musify.Application.Albums.Responses;
 using Musify.Application.Contracts;
 using Musify.Application.Shared;
 using Musify.Application.Tracks.Responses;
+using X.PagedList;
+using X.PagedList.EF;
 
-namespace Musify.Application.Albums;
+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>>>
 {
-    public async ValueTask<ErrorOr<PaginatedResponse<TrackApplicationResponse>>> Handle(GetAlbumTracksQuery request, CancellationToken cancellationToken)
+    public record GetAlbumTracksQuery(
-    {
+        Guid AlbumId,
-        var albumExists = await database.Albums
+        int PageNumber,
-            .AsNoTracking()
+        int PageSize)
-            .Active()
+        : IQuery<ErrorOr<PaginatedResponse<TrackApplicationResponse>>>;
-            .AnyAsync(album => album.Id == request.AlbumId, cancellationToken);
-        if (!albumExists)
-            return AppErrors.NotFound("Album", request.AlbumId);
 
-        return await database.AlbumHasTracks
+    public class GetAlbumTracksQueryHandler(IDatabase database)
-            .AsNoTracking()
+        : IQueryHandler<GetAlbumTracksQuery, ErrorOr<PaginatedResponse<TrackApplicationResponse>>>
-            .Where(albumTrack => albumTrack.AlbumId == request.AlbumId && albumTrack.Track.LifeCycleStatus == Domain.ValueObjects.LifeCycleStatus.Active)
+    {
-            .OrderBy(albumTrack => albumTrack.TrackNumber)
+        public async ValueTask<ErrorOr<PaginatedResponse<TrackApplicationResponse>>> Handle(GetAlbumTracksQuery request, CancellationToken cancellationToken)
-            .ThenBy(albumTrack => albumTrack.Id)
+        {
-            .Select(albumTrack => albumTrack.Track)
+            var albumExists = await database.Albums
-            .SelectResponse()
+                .AsNoTracking()
-            .ToPaginatedAsync(new PageRequest(request.PageNumber, request.PageSize), cancellationToken);
+                .AnyAsync(album => album.Id == request.AlbumId, cancellationToken);
+            if (!albumExists)
+                return Error.NotFound();
+
+            var tracksQuery = database.AlbumHasTracks
+                .AsNoTracking()
+                .Include(albumTrack => albumTrack.Track.Owner)
+                .Include(albumTrack => albumTrack.Track.Tags)
+                .Where(albumTrack => albumTrack.AlbumId == request.AlbumId);
+
+            var totalCount = await tracksQuery.CountAsync(cancellationToken);
+
+            var pagedEntities = await tracksQuery
+                .OrderBy(albumTrack => albumTrack.TrackNumber)
+                .Select(albumTrack => new { albumTrack.Track, ListensCount = albumTrack.Track.ListeningHistories.Count(l => l.IsCounted) })
+                .ToPagedListAsync(request.PageNumber, request.PageSize, totalCount, cancellationToken);
+
+            var pagedTracks = new StaticPagedList<TrackApplicationResponse>(
+                pagedEntities.Select(entry => TrackApplicationResponse.FromEntity(entry.Track, entry.ListensCount)),
+                pagedEntities.PageNumber, pagedEntities.PageSize, pagedEntities.TotalItemCount);
+
+            return PaginatedResponse<TrackApplicationResponse>.FromPagedList(pagedTracks);
+        }
     }
 }

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

@@ -1,33 +1,60 @@
+using ErrorOr;
 using Mediator;
 using Microsoft.EntityFrameworkCore;
 using Musify.Application.Albums.Responses;
 using Musify.Application.Contracts;
-using Musify.Application.Shared;
+using X.PagedList;
+using X.PagedList.EF;
 
-namespace Musify.Application.Albums;
+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>>
 {
-    public async ValueTask<PaginatedResponse<AlbumApplicationResponse>> Handle(GetAlbumsQuery request, CancellationToken cancellationToken)
+    public record GetAlbumsQuery(string? Title, int PageNumber, int PageSize)
+        : IQuery<ErrorOr<AlbumsSearchResponse>>;
+
+    public class GetAlbumsQueryHandler(IDatabase database)
+        : IQueryHandler<GetAlbumsQuery, ErrorOr<AlbumsSearchResponse>>
     {
-        var albumsQuery = database.Albums
+        public async ValueTask<ErrorOr<AlbumsSearchResponse>> Handle(GetAlbumsQuery request, CancellationToken cancellationToken)
-            .AsNoTracking()
-            .Active();
-
-        if (!string.IsNullOrWhiteSpace(request.Title))
         {
-            var normalizedTitle = TextNormalizer.Normalize(request.Title);
+            var albumsQuery = database.Albums
-            albumsQuery = albumsQuery.Where(album => album.NormalizedTitle.Contains(normalizedTitle));
+                .AsNoTracking()
-        }
+                .AsQueryable();
 
-        return await albumsQuery
+            if (!string.IsNullOrEmpty(request.Title))
-            .OrderByDescending(album => album.CreatedAt)
+            {
-            .ThenBy(album => album.Id)
+                var normalizedTitle = request.Title.Trim().ToUpperInvariant();
-            .SelectResponse()
+                albumsQuery = albumsQuery.Where(album => album.NormalizedTitle.Contains(normalizedTitle));
-            .ToPaginatedAsync(new PageRequest(request.PageNumber, request.PageSize), cancellationToken);
+            }
+
+            var totalCount = await albumsQuery.CountAsync(cancellationToken);
+
+            var pagedEntities = await albumsQuery
+                .OrderByDescending(album => album.CreatedAt)
+                .Select(album => new
+                {
+                    Album = album,
+                    TrackCount = album.AlbumTracks.Count,
+                    CoverTrackIds = album.AlbumTracks
+                        .OrderBy(albumTrack => albumTrack.TrackNumber)
+                        .Take(AlbumApplicationResponse.CoverTrackCount)
+                        .Select(albumTrack => albumTrack.TrackId)
+                        .ToList()
+                })
+                .ToPagedListAsync(request.PageNumber, request.PageSize, totalCount, cancellationToken);
+
+            var items = pagedEntities
+                .Select(entry => AlbumSearchItemResponse.FromAlbum(
+                    AlbumApplicationResponse.FromEntity(entry.Album, entry.TrackCount, entry.CoverTrackIds)))
+                .ToList();
+
+            return new AlbumsSearchResponse(
+                items,
+                pagedEntities.PageNumber,
+                pagedEntities.PageSize,
+                pagedEntities.PageCount,
+                pagedEntities.TotalItemCount,
+                pagedEntities.HasPreviousPage,
+                pagedEntities.HasNextPage);
+        }
     }
 }

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

@@ -4,30 +4,50 @@ using Microsoft.EntityFrameworkCore;
 using Musify.Application.Albums.Responses;
 using Musify.Application.Contracts;
 using Musify.Application.Shared;
+using X.PagedList;
+using X.PagedList.EF;
 
-namespace Musify.Application.Albums;
+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>>>
 {
-    public async ValueTask<ErrorOr<PaginatedResponse<AlbumApplicationResponse>>> Handle(GetAlbumsByUserIdQuery request, CancellationToken cancellationToken)
+    public record GetAlbumsByUserIdQuery(long UserId, int PageNumber, int PageSize)
-    {
+        : IQuery<ErrorOr<PaginatedResponse<AlbumApplicationResponse>>>;
-        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
+    public class GetAlbumsByUserIdQueryHandler(IDatabase database)
-            .AsNoTracking()
+        : IQueryHandler<GetAlbumsByUserIdQuery, ErrorOr<PaginatedResponse<AlbumApplicationResponse>>>
-            .Active()
+    {
-            .Where(album => album.OwnerUserId == request.UserId)
+        public async ValueTask<ErrorOr<PaginatedResponse<AlbumApplicationResponse>>> Handle(GetAlbumsByUserIdQuery request, CancellationToken cancellationToken)
-            .OrderByDescending(album => album.CreatedAt)
+        {
-            .ThenBy(album => album.Id)
+            var userExists = await database.Users
-            .SelectResponse()
+                .AsNoTracking()
-            .ToPaginatedAsync(new PageRequest(request.PageNumber, request.PageSize), cancellationToken);
+                .AnyAsync(user => user.Id == request.UserId, cancellationToken);
+            if (!userExists)
+                return Error.NotFound(description: $"User {request.UserId} not found");
+
+            var albumsQuery = database.Albums
+                .AsNoTracking()
+                .Where(album => album.OwnerUserId == request.UserId);
+
+            var totalCount = await albumsQuery.CountAsync(cancellationToken);
+
+            var pagedEntities = await albumsQuery
+                .OrderByDescending(album => album.CreatedAt)
+                .Select(album => new
+                {
+                    Album = album,
+                    TrackCount = album.AlbumTracks.Count,
+                    CoverTrackIds = album.AlbumTracks
+                        .OrderBy(albumTrack => albumTrack.TrackNumber)
+                        .Take(AlbumApplicationResponse.CoverTrackCount)
+                        .Select(albumTrack => albumTrack.TrackId)
+                        .ToList()
+                })
+                .ToPagedListAsync(request.PageNumber, request.PageSize, totalCount, cancellationToken);
+
+            var pagedAlbums = new StaticPagedList<AlbumApplicationResponse>(
+                pagedEntities.Select(entry => AlbumApplicationResponse.FromEntity(entry.Album, entry.TrackCount, entry.CoverTrackIds)),
+                pagedEntities.PageNumber, pagedEntities.PageSize, pagedEntities.TotalItemCount);
+
+            return PaginatedResponse<AlbumApplicationResponse>.FromPagedList(pagedAlbums);
+        }
     }
 }

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

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

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

@@ -3,43 +3,57 @@ using Mediator;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.Logging;
 using Musify.Application.Contracts;
-using Musify.Application.Shared;
 
-namespace Musify.Application.Albums;
+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>>
 {
-    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);
+        public async ValueTask<ErrorOr<Success>> Handle(RemoveTrackFromAlbumCommand request, CancellationToken cancellationToken)
-        if (album.IsError)
+        {
-            return album.Errors;
+            var album = await database.Albums
+                .AsNoTracking()
+                .SingleOrDefaultAsync(a => a.Id == request.AlbumId, cancellationToken);
+            if (album == null)
+            {
+                logger.LogInformation("Album {AlbumId} not found", request.AlbumId);
+                return Error.NotFound();
+            }
 
-        var albumTracks = await database.AlbumHasTracks
+            if (album.OwnerUserId != request.UserId)
-            .Where(albumTrack => albumTrack.AlbumId == request.AlbumId)
+            {
-            .OrderBy(albumTrack => albumTrack.TrackNumber)
+                logger.LogWarning("User {UserId} is not the owner of album {AlbumId}", request.UserId, request.AlbumId);
-            .ToListAsync(cancellationToken);
+                return Error.Unauthorized();
+            }
 
-        var link = albumTracks.SingleOrDefault(albumTrack => albumTrack.TrackId == request.TrackId);
+            var albumTracks = await database.AlbumHasTracks
-        if (link == null)
+                .Where(albumTrack => albumTrack.AlbumId == request.AlbumId)
-            return Error.NotFound("Album.TrackNotFound", "Track is not in the album.");
+                .OrderBy(albumTrack => albumTrack.TrackNumber)
+                .ToListAsync(cancellationToken);
 
-        database.AlbumHasTracks.Remove(link);
+            var link = albumTracks.SingleOrDefault(albumTrack => albumTrack.TrackId == request.TrackId);
+            if (link == null)
+            {
+                logger.LogInformation("Track {TrackId} not in album {AlbumId}", request.TrackId, request.AlbumId);
+                return Error.NotFound(description: "Track is not in the album.");
+            }
 
-        var trackNumber = 1;
+            database.AlbumHasTracks.Remove(link);
-        foreach (var remaining in albumTracks.Where(albumTrack => albumTrack.Id != link.Id))
-            remaining.TrackNumber = trackNumber++;
 
-        await database.SaveChangesAsync(cancellationToken);
+            var trackNumber = 1;
+            foreach (var remaining in albumTracks.Where(albumTrack => albumTrack.Id != link.Id))
+                remaining.TrackNumber = trackNumber++;
 
-        logger.LogInformation("Removed track {TrackId} from album {AlbumId}", request.TrackId, request.AlbumId);
+            await database.SaveChangesAsync(cancellationToken);
 
-        return Result.Success;
+            logger.LogInformation("Removed track {TrackId} from album {AlbumId}", request.TrackId, request.AlbumId);
+
+            return new Success();
+        }
     }
 }

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

@@ -1,24 +1,105 @@
 using ErrorOr;
 using Mediator;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Logging;
 using Musify.Application.Configuration;
-using Musify.Application.Pictures.Responses;
+using Musify.Application.Albums.Responses;
 using Musify.Application.Services;
+using Musify.Domain.Entities;
 using Musify.Domain.ValueObjects;
+using Musify.Application.Contracts;
 
-namespace Musify.Application.Albums;
+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>>
 {
-    public async ValueTask<ErrorOr<PictureUploadResponse>> Handle(RequestAlbumPictureUploadCommand request, CancellationToken cancellationToken) =>
+    public record RequestAlbumPictureUploadCommand(
-        await issuer.IssuePictureAsync(
+        long UserId,
-            request.UserId, UploadIntentPurpose.AlbumPicture, albumConfiguration,
+        string FileType,
-            request.FileType, request.ContentType, request.ExpectedSizeBytes, cancellationToken);
+        string ContentType,
+        long? ExpectedSizeBytes = null)
+        : ICommand<ErrorOr<AlbumPictureUploadResponse>>;
+
+    public class RequestAlbumPictureUploadCommandHandler(
+        IDatabase database,
+        UploadIntentValidator uploadIntentValidator,
+        IStorageService storageService,
+        ILogger<RequestAlbumPictureUploadCommandHandler> logger,
+        ApplicationStorageConfiguration storageConfiguration,
+        AlbumConfiguration albumConfiguration,
+        UploadIntentConfiguration uploadIntentConfiguration)
+        : ICommandHandler<RequestAlbumPictureUploadCommand, ErrorOr<AlbumPictureUploadResponse>>
+    {
+        public async ValueTask<ErrorOr<AlbumPictureUploadResponse>> Handle(RequestAlbumPictureUploadCommand request, CancellationToken cancellationToken)
+        {
+            var userExists = await database.Users
+                .AsNoTracking()
+                .AnyAsync(u => u.Id == request.UserId, cancellationToken);
+            if (!userExists)
+            {
+                logger.LogWarning("User {UserId} not found", request.UserId);
+                return Error.NotFound(description: $"User {request.UserId} not found");
+            }
+
+            var effectiveSizeBytes = request.ExpectedSizeBytes
+                ?? uploadIntentConfiguration.DefaultExpectedPictureSizeBytes;
+
+            var objectName = $"{Guid.NewGuid()}.{request.FileType.TrimStart('.').ToLowerInvariant()}";
+
+            var tempKey = albumConfiguration.Routes.BuildTempPicturePath(
+                uploadIntentConfiguration.TemporalRootPrefix, request.UserId, objectName);
+
+            try
+            {
+                var uploadUrl = await storageService.GetUploadUrlAsync(
+                    storageConfiguration.Bucket,
+                    tempKey,
+                    request.ContentType,
+                    TimeSpan.FromSeconds(uploadIntentConfiguration.UploadUrlExpiresInSeconds),
+                    cancellationToken);
+
+                await using var transaction = await database.BeginTransactionAsync(
+                    System.Data.IsolationLevel.Serializable, cancellationToken);
+
+                var quotaCheck = await uploadIntentValidator.CheckQuotaAsync(
+                    uploadIntentConfiguration,
+                    request.UserId, effectiveSizeBytes, 1, cancellationToken);
+                if (quotaCheck.IsError)
+                {
+                    logger.LogWarning("User {UserId} failed upload intent quota check", request.UserId);
+                    return quotaCheck.Errors;
+                }
+
+                var intent = new UploadIntent
+                {
+                    UserId = request.UserId,
+                    Bucket = storageConfiguration.Bucket,
+                    Key = tempKey,
+                    ObjectName = objectName,
+                    ContentType = request.ContentType,
+                    ExpectedSizeBytes = effectiveSizeBytes,
+                    Purpose = UploadIntentPurpose.AlbumPicture,
+                    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} (AlbumPicture, temp key: {Key})", intent.Id, request.UserId, tempKey);
+
+                return new AlbumPictureUploadResponse(
+                    intent.Id,
+                    storageConfiguration.Bucket,
+                    tempKey,
+                    objectName,
+                    request.ContentType,
+                    uploadIntentConfiguration.UploadUrlExpiresInSeconds,
+                    uploadUrl);
+            }
+            catch (Exception exception)
+            {
+                logger.LogError(exception, "Failed to generate album picture upload URL for user {UserId}", request.UserId);
+                return Error.Failure(description: "Failed to generate upload URL");
+            }
+        }
+    }
 }

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

@@ -1,40 +1,43 @@
+using System.Text.Json.Serialization;
 using Musify.Domain.Entities;
+using Musify.Application.Serialization;
 
-namespace Musify.Application.Albums.Responses;
+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)
 {
-    public const int CoverTrackCount = AlbumProjections.CoverTrackCount;
+    public record AlbumApplicationResponse(
-
+        Guid Id,
-    public static AlbumApplicationResponse FromEntity(
+        string Title,
-        Album album,
+        string? Description,
-        int trackCount,
+        int? ReleaseYear,
-        IReadOnlyList<Guid>? coverTrackIds = null)
+        [property: JsonConverter(typeof(LongAsStringConverter))] long OwnerUserId,
+        int TrackCount,
+        string? SmallImageKeyName,
+        string? MediumImageKeyName,
+        string? LargeImageKeyName,
+        DateTime CreatedAt,
+        DateTime UpdatedAt,
+        IReadOnlyList<Guid> CoverTrackIds)
     {
-        return new AlbumApplicationResponse(
+        public const int CoverTrackCount = 4;
-            album.Id,
+
-            album.Title,
+        public static AlbumApplicationResponse FromEntity(
-            album.Description,
+            Album album,
-            album.ReleaseYear,
+            int trackCount,
-            album.OwnerUserId,
+            IReadOnlyList<Guid>? coverTrackIds = null)
-            trackCount,
+        {
-            album.Pictures?.SmallName,
+            return new AlbumApplicationResponse(
-            album.Pictures?.MediumName,
+                album.Id,
-            album.Pictures?.LargeName,
+                album.Title,
-            album.CreatedAt,
+                album.Description,
-            album.UpdatedAt,
+                album.ReleaseYear,
-            coverTrackIds ?? []);
+                album.OwnerUserId,
+                trackCount,
+                album.Pictures?.SmallName,
+                album.Pictures?.MediumName,
+                album.Pictures?.LargeName,
+                album.CreatedAt,
+                album.UpdatedAt,
+                coverTrackIds ?? []);
+        }
     }
 }

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

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

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

@@ -1,31 +0,0 @@
-using Musify.Domain.Entities;
-using Musify.Domain.ValueObjects;
-
-namespace Musify.Application.Albums.Responses;
-
-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<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/Responses/AlbumSearchItemResponse.cs

@@ -0,0 +1,7 @@
+namespace Musify.Application.Albums.Responses
+{
+    public record AlbumSearchItemResponse(AlbumApplicationResponse Album)
+    {
+        public static AlbumSearchItemResponse FromAlbum(AlbumApplicationResponse album) => new(album);
+    }
+}

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

@@ -0,0 +1,12 @@
+namespace Musify.Application.Albums.Responses
+{
+
+    public record AlbumsSearchResponse(
+        IReadOnlyList<AlbumSearchItemResponse> Items,
+        int PageNumber,
+        int PageSize,
+        int PageCount,
+        int TotalItemCount,
+        bool HasPreviousPage,
+        bool HasNextPage);
+}

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

@@ -2,72 +2,149 @@ using ErrorOr;
 using Mediator;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.Logging;
-using Musify.Application.Albums.Responses;
 using Musify.Application.Configuration;
-using Musify.Application.Contracts;
-using Musify.Application.Events;
-using Musify.Application.Pictures;
-using Musify.Application.Services;
 using Musify.Application.Shared;
+using Musify.Application.Events;
+using Musify.Application.Albums.Responses;
+using Musify.Application.Services;
+using Musify.Domain.Entities;
 using Musify.Domain.ValueObjects;
+using Musify.Application.Contracts;
 
-namespace Musify.Application.Albums;
+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>>
 {
-    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,
+        ApplicationStorageConfiguration storageConfiguration,
+        AlbumConfiguration albumConfiguration,
+        UploadIntentConfiguration uploadIntentConfiguration)
+        : ICommandHandler<UpdateAlbumCommand, ErrorOr<AlbumApplicationResponse>>
     {
-        var found = await database.Albums.FindOwnedAsync(request.AlbumId, request.UserId, cancellationToken);
+        public async ValueTask<ErrorOr<AlbumApplicationResponse>> Handle(UpdateAlbumCommand request, CancellationToken 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)
         {
-            var prepared = await PictureSourceChange.PrepareAsync(
+            var album = await database.Albums
-                uploadIntentValidator, intentId, request.UserId, UploadIntentPurpose.AlbumPicture, albumConfiguration, cancellationToken);
+                .SingleOrDefaultAsync(a => a.Id == request.AlbumId, cancellationToken);
-            if (prepared.IsError)
+            if (album == null)
-                return prepared.Errors;
+            {
+                logger.LogInformation("Album {AlbumId} not found", request.AlbumId);
+                return Error.NotFound();
+            }
 
-            var picture = prepared.Value;
+            if (album.OwnerUserId != request.UserId)
-            album.Pictures = picture.Pictures;
+            {
+                logger.LogWarning("Album {AlbumId} does not belong to user {UserId}", request.AlbumId, request.UserId);
+                return Error.Unauthorized();
+            }
 
-            await eventBus.PublishAsync(
+            var title = request.Title.Trim();
-                new UpdateAlbumPictureSourceEvent(
+
-                    album.Id, picture.Intent.Id, picture.Intent.Bucket, picture.Intent.Key, picture.FinalKey, picture.Sizes),
+            album.Title = title;
-                cancellationToken);
+            album.NormalizedTitle = title.ToUpperInvariant();
+            album.Description = request.Description;
+            album.ReleaseYear = request.ReleaseYear;
+
+            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;
+                album.Pictures = new AlbumPictures
+                {
+                    OriginalName = pictureIntent.ObjectName,
+                    SmallName = pictureIntent.ObjectName,
+                    MediumName = pictureIntent.ObjectName,
+                    LargeName = pictureIntent.ObjectName
+                };
+                finalPictureKey = albumConfiguration.Routes.BuildOriginalPicturePath(request.UserId, pictureIntent.ObjectName);
+            }
+
+            if (pictureIntent != null && finalPictureKey != null)
+            {
+                var publishResult = await PublishUpdateAlbumPictureSourceEventAsync(
+                    album.Id, pictureIntent, finalPictureKey, cancellationToken);
+                if (publishResult.IsError)
+                    return publishResult.Errors;
+            }
+
+            try
+            {
+                await database.SaveChangesAsync(cancellationToken);
+            }
+            catch (Exception exception)
+            {
+                logger.LogError(exception, "Failed to update album {AlbumId}", request.AlbumId);
+                return Error.Failure(description: $"Failed to update album {request.AlbumId}");
+            }
+
+            var albumTracks = database.AlbumHasTracks
+                .AsNoTracking()
+                .Where(albumTrack => albumTrack.AlbumId == album.Id);
+
+            var trackCount = await albumTracks.CountAsync(cancellationToken);
+            var coverTrackIds = await albumTracks
+                .OrderBy(albumTrack => albumTrack.TrackNumber)
+                .Take(AlbumApplicationResponse.CoverTrackCount)
+                .Select(albumTrack => albumTrack.TrackId)
+                .ToListAsync(cancellationToken);
+
+            logger.LogInformation("Updated album {AlbumId}", album.Id);
+            return AlbumApplicationResponse.FromEntity(album, trackCount, coverTrackIds);
         }
 
-        await database.SaveChangesAsync(cancellationToken);
+        private async Task<ErrorOr<Success>> PublishUpdateAlbumPictureSourceEventAsync(
-
+            Guid albumId,
-        logger.LogInformation("Updated album {AlbumId}", album.Id);
+            UploadIntent pictureIntent,
-
+            string finalPictureKey,
-        return await database.Albums
+            CancellationToken cancellationToken)
-            .AsNoTracking()
+        {
-            .Where(a => a.Id == album.Id)
+            try
-            .SelectResponse()
+            {
-            .SingleAsync(cancellationToken);
+                await eventBus.PublishAsync(
+                    new UpdateAlbumPictureSourceEvent(
+                        albumId,
+                        pictureIntent.Id,
+                        storageConfiguration.Bucket,
+                        pictureIntent.Key,
+                        finalPictureKey,
+                        new ImageSize(
+                            albumConfiguration.Routes.SmallPicturesPath,
+                            albumConfiguration.PicturesSizes.SmallPictureWidth,
+                            albumConfiguration.PicturesSizes.SmallPictureHeight),
+                        new ImageSize(
+                            albumConfiguration.Routes.MediumPicturesPath,
+                            albumConfiguration.PicturesSizes.MediumPictureWidth,
+                            albumConfiguration.PicturesSizes.MediumPictureHeight),
+                        new ImageSize(
+                            albumConfiguration.Routes.LargePicturesPath,
+                            albumConfiguration.PicturesSizes.LargePictureWidth,
+                            albumConfiguration.PicturesSizes.LargePictureHeight)),
+                    cancellationToken);
+                return new Success();
+            }
+            catch (Exception exception)
+            {
+                logger.LogError(exception, "Failed to publish update album picture source event for album {AlbumId}", albumId);
+                return Error.Failure(description: $"Failed to publish update album picture source event for album {albumId}");
+            }
+        }
     }
 }

backend/Core/Musify.Application/Application.csproj

@@ -19,6 +19,8 @@
     <PackageReference Include="Microsoft.Extensions.Options.ConfigurationExtensions" />
     <PackageReference Include="Microsoft.Extensions.Options.DataAnnotations" />
     <PackageReference Include="MimeMapping" />
+    <PackageReference Include="X.PagedList" />
+    <PackageReference Include="X.PagedList.EF" />
   </ItemGroup>
 
   <ItemGroup>

backend/Core/Musify.Application/ApplicationDependencyInjection.cs

@@ -11,17 +11,16 @@ public static class ApplicationDependencyInjection
     {
         services.AddMediator();
         services.AddScoped<UploadIntentValidator>();
-        services.AddScoped<UploadIntentIssuer>();
         services.AddScoped<TrackStreamIssuer>();
 
-        services.AddValidatedOptions<ApplicationStorageConfiguration>(configuration);
+        services.AddValidatedOptions<ApplicationStorageConfiguration>(configuration, ApplicationStorageConfiguration.SectionName);
-        services.AddValidatedOptions<PlayListConfiguration>(configuration);
+        services.AddValidatedOptions<PlayListConfiguration>(configuration, PlayListConfiguration.SectionName);
-        services.AddValidatedOptions<AlbumConfiguration>(configuration);
+        services.AddValidatedOptions<AlbumConfiguration>(configuration, AlbumConfiguration.SectionName);
-        services.AddValidatedOptions<TrackConfiguration>(configuration);
+        services.AddValidatedOptions<TrackConfiguration>(configuration, TrackConfiguration.SectionName);
-        services.AddValidatedOptions<MixConfiguration>(configuration);
+        services.AddValidatedOptions<MixConfiguration>(configuration, MixConfiguration.SectionName);
-        services.AddValidatedOptions<StreamGatewayConfiguration>(configuration);
+        services.AddValidatedOptions<StreamGatewayConfiguration>(configuration, StreamGatewayConfiguration.SectionName);
-        services.AddValidatedOptions<UploadIntentConfiguration>(configuration);
+        services.AddValidatedOptions<UploadIntentConfiguration>(configuration, UploadIntentConfiguration.SectionName);
-        services.AddValidatedOptions<PlaybackConfiguration>(configuration);
+        services.AddValidatedOptions<PlaybackConfiguration>(configuration, PlaybackConfiguration.SectionName);
 
         return services;
     }

backend/Core/Musify.Application/AssemblyInfo.cs

@@ -1,4 +1,4 @@
-using Mediator;
+using Mediator;
 using Microsoft.Extensions.DependencyInjection;
 
 [assembly: MediatorOptions(ServiceLifetime = ServiceLifetime.Scoped)]

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

@@ -1,14 +1,79 @@
 using System.ComponentModel.DataAnnotations;
+using Musify.Application.Shared;
 
-namespace Musify.Application.Configuration;
+namespace Musify.Application.Configuration
-
-public class AlbumConfiguration : IConfigurationOptions, IPictureOwnerConfiguration
 {
-    public static string SectionName => "Album";
+    public class AlbumConfiguration
+    {
+        public const string SectionName = "Album";
 
-    [Required]
+        [Required]
-    public PictureRoutes Routes { get; set; } = new() { ParentFolder = "Albums" };
+        public AlbumRoutes Routes { get; set; } = new AlbumRoutes();
 
-    [Required]
+        [Required]
-    public PictureSizes PicturesSizes { get; set; } = new();
+        public AlbumPicturesSizes PicturesSizes { get; set; } = new AlbumPicturesSizes();
+    }
+
+    public class AlbumRoutes
+    {
+        [Required]
+        public string UploadsFolder { get; set; } = "uploads";
+
+        [Required]
+        public string ParentFolders { get; set; } = "Albums";
+
+        [Required]
+        public string OriginalPicturesFolder { get; set; } = "OriginalPictures";
+
+        [Required]
+        public string SmallPicturesFolder { get; set; } = "SmallPictures";
+
+        [Required]
+        public string MediumPicturesFolder { get; set; } = "MediumPictures";
+
+        [Required]
+        public string LargePicturesFolder { get; set; } = "LargePictures";
+
+        public string SmallPicturesPath => StorageKey.Combine(ParentFolders, SmallPicturesFolder);
+
+        public string MediumPicturesPath => StorageKey.Combine(ParentFolders, MediumPicturesFolder);
+
+        public string LargePicturesPath => StorageKey.Combine(ParentFolders, LargePicturesFolder);
+
+        public string OriginalPicturesPath => StorageKey.Combine(ParentFolders, OriginalPicturesFolder);
+
+        public string BuildOriginalPicturePath(string pictureName) => StorageKey.Combine(ParentFolders, OriginalPicturesFolder, pictureName);
+
+        public string BuildOriginalPicturePath(long userId, string pictureName) => StorageKey.Combine(UploadsFolder, userId.ToString(), ParentFolders, OriginalPicturesFolder, pictureName);
+
+        public string BuildSmallPicturePath(string pictureName) => StorageKey.Combine(ParentFolders, SmallPicturesFolder, pictureName);
+
+        public string BuildMediumPicturePath(string pictureName) => StorageKey.Combine(ParentFolders, MediumPicturesFolder, pictureName);
+
+        public string BuildLargePicturePath(string pictureName) => StorageKey.Combine(ParentFolders, LargePicturesFolder, pictureName);
+
+        public string BuildTempPicturePath(string tempRootPrefix, long userId, string objectName) =>
+            StorageKey.Combine(tempRootPrefix, userId.ToString(), ParentFolders, objectName);
+    }
+
+    public class AlbumPicturesSizes
+    {
+        [Range(1, 1024)]
+        public int SmallPictureWidth { get; set; } = 128;
+
+        [Range(1, 1024)]
+        public int SmallPictureHeight { get; set; } = 128;
+
+        [Range(1, 1024)]
+        public int MediumPictureWidth { get; set; } = 256;
+
+        [Range(1, 1024)]
+        public int MediumPictureHeight { get; set; } = 256;
+
+        [Range(1, 1024)]
+        public int LargePictureWidth { get; set; } = 512;
+
+        [Range(1, 1024)]
+        public int LargePictureHeight { get; set; } = 512;
+    }
 }

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

@@ -1,12 +1,13 @@
 using System.ComponentModel.DataAnnotations;
 
-namespace Musify.Application.Configuration;
+namespace Musify.Application.Configuration
-
-public class ApplicationStorageConfiguration : IConfigurationOptions
 {
-    public static string SectionName => "ApplicationStorage";
+    public class ApplicationStorageConfiguration
+    {
+        public const string SectionName = "ApplicationStorage";
 
-    [Required]
+        [Required]
-    [StringLength(128, MinimumLength = 1)]
+        [StringLength(128, MinimumLength = 1)]
-    public required string Bucket { get; set; }
+        public required string Bucket { get; set; }
+    }
 }

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

@@ -6,10 +6,6 @@ namespace Musify.Application.Configuration;
 
 public static class ConfigurationDependencyInjection
 {
-    public static IServiceCollection AddValidatedOptions<T>(this IServiceCollection services, IConfiguration configuration)
-        where T : class, IConfigurationOptions =>
-        services.AddValidatedOptions<T>(configuration, T.SectionName);
-
     public static IServiceCollection AddValidatedOptions<T>(
         this IServiceCollection services,
         IConfiguration configuration,

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

@@ -1,16 +1,17 @@
 using Mediator;
 using Musify.Application.Configuration.Responses;
 
-namespace Musify.Application.Configuration;
+namespace Musify.Application.Configuration
-
-
-public record GetPlaybackPublicConfigQuery : IQuery<PlaybackPublicConfigResponse>;
-
-public class GetPlaybackPublicConfigQueryHandler(PlaybackConfiguration playbackConfiguration)
-    : IQueryHandler<GetPlaybackPublicConfigQuery, PlaybackPublicConfigResponse>
 {
-    public ValueTask<PlaybackPublicConfigResponse> Handle(GetPlaybackPublicConfigQuery query, CancellationToken cancellationToken) =>
+
-        ValueTask.FromResult(new PlaybackPublicConfigResponse(
+    public record GetPlaybackPublicConfigQuery : IQuery<PlaybackPublicConfigResponse>;
-            playbackConfiguration.AllowAnonymousListening,
+
-            playbackConfiguration.AnonymousFragmentSeconds));
+    public class GetPlaybackPublicConfigQueryHandler(PlaybackConfiguration playbackConfiguration)
+        : IQueryHandler<GetPlaybackPublicConfigQuery, PlaybackPublicConfigResponse>
+    {
+        public ValueTask<PlaybackPublicConfigResponse> Handle(GetPlaybackPublicConfigQuery query, CancellationToken cancellationToken) =>
+            ValueTask.FromResult(new PlaybackPublicConfigResponse(
+                playbackConfiguration.AllowAnonymousListening,
+                playbackConfiguration.AnonymousFragmentSeconds));
+    }
 }

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

@@ -1,6 +0,0 @@
-namespace Musify.Application.Configuration;
-
-public interface IConfigurationOptions
-{
-    public static abstract string SectionName { get; }
-}

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

@@ -1,11 +1,12 @@
 using System.ComponentModel.DataAnnotations;
 
-namespace Musify.Application.Configuration;
+namespace Musify.Application.Configuration
-
-public class MixConfiguration : IConfigurationOptions
 {
-    public static string SectionName => "Mix";
+    public class MixConfiguration
+    {
+        public const string SectionName = "Mix";
 
-    [Range(4, 100)]
+        [Range(4, 100)]
-    public int ItemsPerMix { get; set; } = 12;
+        public int ItemsPerMix { get; set; } = 12;
+    }
 }

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

@@ -1,90 +0,0 @@
-using System.ComponentModel.DataAnnotations;
-using Musify.Application.Shared;
-
-namespace Musify.Application.Configuration;
-
-public enum PictureSize
-{
-    Small,
-    Medium,
-    Large
-}
-
-public class PictureRoutes
-{
-    [Required]
-    public string UploadsFolder { get; set; } = "uploads";
-
-    [Required]
-    public string ParentFolder { get; set; } = string.Empty;
-
-    [Required]
-    public string OriginalPicturesFolder { get; set; } = "OriginalPictures";
-
-    [Required]
-    public string SmallPicturesFolder { get; set; } = "SmallPictures";
-
-    [Required]
-    public string MediumPicturesFolder { get; set; } = "MediumPictures";
-
-    [Required]
-    public string LargePicturesFolder { get; set; } = "LargePictures";
-
-    public string FolderPath(PictureSize size) => StorageKey.Combine(ParentFolder, size switch
-    {
-        PictureSize.Small => SmallPicturesFolder,
-        PictureSize.Medium => MediumPicturesFolder,
-        PictureSize.Large => LargePicturesFolder,
-        _ => throw new ArgumentOutOfRangeException(nameof(size), size, null)
-    });
-
-    public string BuildPicturePath(PictureSize size, string pictureName) => StorageKey.Combine(FolderPath(size), pictureName);
-
-    public string BuildOriginalPicturePath(long userId, string pictureName) =>
-        StorageKey.Combine(UploadsFolder, userId.ToString(), ParentFolder, OriginalPicturesFolder, pictureName);
-
-    public string BuildTempPath(string tempRootPrefix, long userId, string objectName) =>
-        StorageKey.Combine(tempRootPrefix, userId.ToString(), ParentFolder, objectName);
-}
-
-public class PictureSizes
-{
-    [Range(1, 1024)]
-    public int SmallWidth { get; set; } = 128;
-
-    [Range(1, 1024)]
-    public int SmallHeight { get; set; } = 128;
-
-    [Range(1, 1024)]
-    public int MediumWidth { get; set; } = 256;
-
-    [Range(1, 1024)]
-    public int MediumHeight { get; set; } = 256;
-
-    [Range(1, 1024)]
-    public int LargeWidth { get; set; } = 512;
-
-    [Range(1, 1024)]
-    public int LargeHeight { get; set; } = 512;
-
-    public ImageSizes ToImageSizes(PictureRoutes routes) => new(
-        new ImageSize(routes.FolderPath(PictureSize.Small), SmallWidth, SmallHeight),
-        new ImageSize(routes.FolderPath(PictureSize.Medium), MediumWidth, MediumHeight),
-        new ImageSize(routes.FolderPath(PictureSize.Large), LargeWidth, LargeHeight));
-}
-
-public interface IPictureOwnerConfiguration
-{
-    public PictureRoutes Routes { get; }
-
-    public PictureSizes PicturesSizes { get; }
-}
-
-public static class PictureSizeParser
-{
-    /// <summary>Parses the <c>size</c> query value; anything unknown means <see cref="PictureSize.Medium"/>.</summary>
-    public static PictureSize Parse(string? value) =>
-        Enum.TryParse<PictureSize>(value, ignoreCase: true, out var size) && Enum.IsDefined(size)
-            ? size
-            : PictureSize.Medium;
-}

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

@@ -1,14 +1,79 @@
 using System.ComponentModel.DataAnnotations;
+using Musify.Application.Shared;
 
-namespace Musify.Application.Configuration;
+namespace Musify.Application.Configuration
-
-public class PlayListConfiguration : IConfigurationOptions, IPictureOwnerConfiguration
 {
-    public static string SectionName => "PlayList";
+    public class PlayListConfiguration
+    {
+        public const string SectionName = "PlayList";
 
-    [Required]
+        [Required]
-    public PictureRoutes Routes { get; set; } = new() { ParentFolder = "PlayLists" };
+        public PlayListRoutes Routes { get; set; } = new PlayListRoutes();
 
-    [Required]
+        [Required]
-    public PictureSizes PicturesSizes { get; set; } = new();
+        public PlayListPicturesSizes PicturesSizes { get; set; } = new PlayListPicturesSizes();
+    }
+
+    public class PlayListRoutes
+    {
+        [Required]
+        public string UploadsFolder { get; set; } = "uploads";
+
+        [Required]
+        public string ParentFolders { get; set; } = "PlayLists";
+
+        [Required]
+        public string OriginalPicturesFolder { get; set; } = "OriginalPictures";
+
+        [Required]
+        public string SmallPicturesFolder { get; set; } = "SmallPictures";
+
+        [Required]
+        public string MediumPicturesFolder { get; set; } = "MediumPictures";
+
+        [Required]
+        public string LargePicturesFolder { get; set; } = "LargePictures";
+
+        public string SmallPicturesPath => StorageKey.Combine(ParentFolders, SmallPicturesFolder);
+
+        public string MediumPicturesPath => StorageKey.Combine(ParentFolders, MediumPicturesFolder);
+
+        public string LargePicturesPath => StorageKey.Combine(ParentFolders, LargePicturesFolder);
+
+        public string OriginalPicturesPath => StorageKey.Combine(ParentFolders, OriginalPicturesFolder);
+
+        public string BuildOriginalPicturePath(string pictureName) => StorageKey.Combine(ParentFolders, OriginalPicturesFolder, pictureName);
+
+        public string BuildOriginalPicturePath(long userId, string pictureName) => StorageKey.Combine(UploadsFolder, userId.ToString(), ParentFolders, OriginalPicturesFolder, pictureName);
+
+        public string BuildSmallPicturePath(string pictureName) => StorageKey.Combine(ParentFolders, SmallPicturesFolder, pictureName);
+
+        public string BuildMediumPicturePath(string pictureName) => StorageKey.Combine(ParentFolders, MediumPicturesFolder, pictureName);
+
+        public string BuildLargePicturePath(string pictureName) => StorageKey.Combine(ParentFolders, LargePicturesFolder, pictureName);
+
+        public string BuildTempPicturePath(string tempRootPrefix, long userId, string objectName) =>
+            StorageKey.Combine(tempRootPrefix, userId.ToString(), ParentFolders, objectName);
+    }
+
+    public class PlayListPicturesSizes
+    {
+        [Range(1, 1024)]
+        public int SmallPictureWidth { get; set; } = 128;
+
+        [Range(1, 1024)]
+        public int SmallPictureHeight { get; set; } = 128;
+
+        [Range(1, 1024)]
+        public int MediumPictureWidth { get; set; } = 256;
+
+        [Range(1, 1024)]
+        public int MediumPictureHeight { get; set; } = 256;
+
+        [Range(1, 1024)]
+        public int LargePictureWidth { get; set; } = 512;
+
+        [Range(1, 1024)]
+        public int LargePictureHeight { get; set; } = 512;
+    }
 }

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

@@ -1,17 +1,18 @@
 using System.ComponentModel.DataAnnotations;
 
-namespace Musify.Application.Configuration;
+namespace Musify.Application.Configuration
-
-
-public sealed class PlaybackConfiguration : IConfigurationOptions
 {
-    public static string SectionName => "Playback";
 
-    public bool AllowAnonymousListening { get; set; }
+    public sealed class PlaybackConfiguration
+    {
+        public const string SectionName = "Playback";
 
-    [Range(0, 3600)]
+        public bool AllowAnonymousListening { get; set; }
-    public int AnonymousFragmentSeconds { get; set; }
 
-    [Range(1, int.MaxValue)]
+        [Range(0, 3600)]
-    public int EstimatedAudioBytesPerSecond { get; set; } = 16_000;
+        public int AnonymousFragmentSeconds { get; set; }
+
+        [Range(1, int.MaxValue)]
+        public int EstimatedAudioBytesPerSecond { get; set; } = 16_000;
+    }
 }

backend/Core/Musify.Application/Configuration/Responses/PlaybackPublicConfigResponse.cs

@@ -1,4 +1,5 @@
-namespace Musify.Application.Configuration.Responses;
+namespace Musify.Application.Configuration.Responses
+{
 
-
+    public record PlaybackPublicConfigResponse(bool AllowAnonymousListening, int AnonymousFragmentSeconds);
-public record PlaybackPublicConfigResponse(bool AllowAnonymousListening, int AnonymousFragmentSeconds);
+}

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

@@ -1,15 +1,16 @@
 using System.ComponentModel.DataAnnotations;
 
-namespace Musify.Application.Configuration;
+namespace Musify.Application.Configuration
-
-public class StreamGatewayConfiguration : IConfigurationOptions
 {
-    public static string SectionName => "StreamGateway";
+    public class StreamGatewayConfiguration
+    {
+        public const string SectionName = "StreamGateway";
 
-    [Url]
+        [Url]
-    [Required]
+        [Required]
-    public required string PublicBaseUrl { get; set; }
+        public required string PublicBaseUrl { get; set; }
 
-    [Required]
+        [Required]
-    public string AudioFileName { get; set; } = "audio.m4a";
+        public string AudioFileName { get; set; } = "audio.m4a";
+    }
 }

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

@@ -1,55 +1,116 @@
 using System.ComponentModel.DataAnnotations;
 using Musify.Application.Shared;
 
-namespace Musify.Application.Configuration;
+namespace Musify.Application.Configuration
-
-public class TrackConfiguration : IConfigurationOptions, IPictureOwnerConfiguration
 {
-    public static string SectionName => "Track";
+    public class TrackConfiguration
-
-    [Required]
-    public TrackRoutes Routes { get; set; } = new();
-
-    [Required]
-    public PictureSizes PicturesSizes { get; set; } = new();
-
-    PictureRoutes IPictureOwnerConfiguration.Routes => Routes;
-}
-
-public class TrackRoutes : PictureRoutes
-{
-    public TrackRoutes()
     {
-        ParentFolder = "Tracks";
+        public const string SectionName = "Track";
+
+        [Required]
+        public TrackRoutes Routes { get; set; } = new TrackRoutes();
+
+        [Required]
+        public TrackPicturesSizes PicturesSizes { get; set; } = new TrackPicturesSizes();
     }
 
-    [Required]
+    public class TrackRoutes
-    public string PresetOriginalPicture { get; set; } = "PresetOriginalPicture.webp";
+    {
+        [Required]
+        public string UploadsFolder { get; set; } = "uploads";
 
-    [Required]
+        [Required]
-    public string PresetSmallPicture { get; set; } = "PresetSmallPicture.webp";
+        public string ParentFolder { get; set; } = "Tracks";
 
-    [Required]
+        [Required]
-    public string PresetMediumPicture { get; set; } = "PresetMediumPicture.webp";
+        public string OriginalPicturesFolder { get; set; } = "OriginalPictures";
 
-    [Required]
+        [Required]
-    public string PresetLargePicture { get; set; } = "PresetLargePicture.webp";
+        public string SmallPicturesFolder { get; set; } = "SmallPictures";
 
-    [Required]
+        [Required]
-    public string OriginalAudiosFolder { get; set; } = "OriginalAudios";
+        public string MediumPicturesFolder { get; set; } = "MediumPictures";
 
-    [Required]
+        [Required]
-    public string ProcessedAudiosFolder { get; set; } = "ProcessedAudios";
+        public string LargePicturesFolder { get; set; } = "LargePictures";
 
-    public string PresetSmallPicturePath => StorageKey.Combine(ParentFolder, PresetSmallPicture);
+        [Required]
+        public string PresetOriginalPicture { get; set; } = "PresetOriginalPicture.webp";
 
-    public string PresetMediumPicturePath => StorageKey.Combine(ParentFolder, PresetMediumPicture);
+        [Required]
+        public string PresetSmallPicture { get; set; } = "PresetSmallPicture.webp";
 
-    public string PresetLargePicturePath => StorageKey.Combine(ParentFolder, PresetLargePicture);
+        [Required]
+        public string PresetMediumPicture { get; set; } = "PresetMediumPicture.webp";
 
-    public string BuildOriginalAudioPath(long userId, string audioName) =>
+        [Required]
-        StorageKey.Combine(UploadsFolder, userId.ToString(), ParentFolder, OriginalAudiosFolder, audioName);
+        public string PresetLargePicture { get; set; } = "PresetLargePicture.webp";
 
-    public string BuildProcessedAudioPath(string folderName) =>
+        [Required]
-        StorageKey.Combine(ParentFolder, ProcessedAudiosFolder, folderName);
+        public string OriginalAudiosFolder { get; set; } = "OriginalAudios";
+
+        [Required]
+        public string ProcessedAudioFolder { get; set; } = "ProcessedAudios";
+
+        public string SmallPicturesPath => StorageKey.Combine(ParentFolder, SmallPicturesFolder);
+
+        public string MediumPicturesPath => StorageKey.Combine(ParentFolder, MediumPicturesFolder);
+
+        public string LargePicturesPath => StorageKey.Combine(ParentFolder, LargePicturesFolder);
+
+        public string PresetSmallPicturePath => StorageKey.Combine(ParentFolder, PresetSmallPicture);
+
+        public string PresetMediumPicturePath => StorageKey.Combine(ParentFolder, PresetMediumPicture);
+
+        public string PresetLargePicturePath => StorageKey.Combine(ParentFolder, PresetLargePicture);
+
+        public string OriginalPicturesPath => StorageKey.Combine(ParentFolder, OriginalPicturesFolder);
+
+        public string OriginalAudiosPath => StorageKey.Combine(ParentFolder, OriginalAudiosFolder);
+
+        public string ProcessedAudiosPath => StorageKey.Combine(ParentFolder, ProcessedAudioFolder);
+
+        public string BuildOriginalPicturePath(string pictureName) => StorageKey.Combine(OriginalPicturesPath, pictureName);
+
+        public string BuildOriginalPicturePath(long userId, string pictureName) => StorageKey.Combine(UploadsFolder, userId.ToString(), OriginalPicturesPath, pictureName);
+
+        public string BuildSmallPicturePath(string pictureName) => StorageKey.Combine(SmallPicturesPath, pictureName);
+
+        public string BuildMediumPicturePath(string pictureName) => StorageKey.Combine(MediumPicturesPath, pictureName);
+
+        public string BuildLargePicturePath(string pictureName) => StorageKey.Combine(LargePicturesPath, pictureName);
+
+        public string BuildOriginalAudioPath(string audioName) => StorageKey.Combine(OriginalAudiosPath, audioName);
+
+        public string BuildOriginalAudioPath(long userId, string audioName) => StorageKey.Combine(UploadsFolder, userId.ToString(), OriginalAudiosPath, audioName);
+
+        public string BuildProcessedAudioPath(string audioName) => StorageKey.Combine(ProcessedAudiosPath, audioName);
+
+        public string BuildTempPicturePath(string tempRootPrefix, long userId, string objectName) =>
+            StorageKey.Combine(tempRootPrefix, userId.ToString(), ParentFolder, objectName);
+
+        public string BuildTempAudioPath(string tempRootPrefix, long userId, string objectName) =>
+            StorageKey.Combine(tempRootPrefix, userId.ToString(), ParentFolder, objectName);
+    }
+
+    public class TrackPicturesSizes
+    {
+        [Range(1, 1024)]
+        public int SmallPictureWidth { get; set; } = 128;
+
+        [Range(1, 1024)]
+        public int SmallPictureHeight { get; set; } = 128;
+
+        [Range(1, 1024)]
+        public int MediumPictureWidth { get; set; } = 256;
+
+        [Range(1, 1024)]
+        public int MediumPictureHeight { get; set; } = 256;
+
+        [Range(1, 1024)]
+        public int LargePictureWidth { get; set; } = 512;
+
+        [Range(1, 1024)]
+        public int LargePictureHeight { get; set; } = 512;
+    }
 }

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

@@ -1,41 +1,42 @@
 using System.ComponentModel.DataAnnotations;
 
-namespace Musify.Application.Configuration;
+namespace Musify.Application.Configuration
-
-public class UploadIntentConfiguration : IConfigurationOptions
 {
-    public static string SectionName => "UploadIntent";
+    public class UploadIntentConfiguration
+    {
+        public const string SectionName = "UploadIntent";
 
-    [Range(10, 3600)]
+        [Range(10, 3600)]
-    public int UploadUrlExpiresInSeconds { get; set; } = 120;
+        public int UploadUrlExpiresInSeconds { get; set; } = 120;
 
-    [Range(1, 100)]
+        [Range(1, 100)]
-    public int MaxActiveUploadIntentsPerUser { get; set; } = 5;
+        public int MaxActiveUploadIntentsPerUser { get; set; } = 5;
 
-    [Range(1, long.MaxValue)]
+        [Range(1, long.MaxValue)]
-    public long MaxActiveUploadBytesPerUser { get; set; } = 200L * 1024 * 1024;
+        public long MaxActiveUploadBytesPerUser { get; set; } = 200L * 1024 * 1024;
 
-    [Range(1, long.MaxValue)]
+        [Range(1, long.MaxValue)]
-    public long MaxUploadBytes { get; set; } = 100L * 1024 * 1024;
+        public long MaxUploadBytes { get; set; } = 100L * 1024 * 1024;
 
-    [Range(1, long.MaxValue)]
+        [Range(1, long.MaxValue)]
-    public long DefaultExpectedPictureSizeBytes { get; set; } = 10L * 1024 * 1024;
+        public long DefaultExpectedPictureSizeBytes { get; set; } = 10L * 1024 * 1024;
 
-    [Range(1, long.MaxValue)]
+        [Range(1, long.MaxValue)]
-    public long DefaultExpectedAudioSizeBytes { get; set; } = 100L * 1024 * 1024;
+        public long DefaultExpectedAudioSizeBytes { get; set; } = 100L * 1024 * 1024;
 
-    [Range(30, 86400)]
+        [Range(30, 86400)]
-    public int ExpirationJobIntervalSeconds { get; set; } = 300;
+        public int ExpirationJobIntervalSeconds { get; set; } = 300;
 
-    [Range(0, 365)]
+        [Range(0, 365)]
-    public int ExpiredIntentsRetentionDays { get; set; } = 7;
+        public int ExpiredIntentsRetentionDays { get; set; } = 7;
 
-    [Required, MinLength(1)]
+        [Required, MinLength(1)]
-    public string TempRootPrefix { get; set; } = "temp";
+        public string TemporalRootPrefix { get; set; } = "temporal";
 
-    [Range(1, 30)]
+        [Range(1, 30)]
-    public int TempUploadsRetentionDays { get; set; } = 3;
+        public int TemporalUploadsRetentionDays { get; set; } = 3;
 
-    [Range(60, 86400)]
+        [Range(60, 86400)]
-    public int TempCleanupJobIntervalSeconds { get; set; } = 3600;
+        public int TemporalCleanUpJobIntervalSeconds { get; set; } = 3600;
+    }
 }

backend/Core/Musify.Application/Contracts/AudioTranscodeResult.cs

@@ -1,3 +1,4 @@
-namespace Musify.Application.Contracts;
+namespace Musify.Application.Contracts
-
+{
-public record AudioTranscodeResult(int StatusCode, TimeSpan Duration);
+    public record AudioTranscodeResult(int StatusCode, TimeSpan Duration);
+}

backend/Core/Musify.Application/Contracts/IAudioTranscoderService.cs

@@ -1,6 +1,9 @@
-namespace Musify.Application.Contracts;
+namespace Musify.Application.Contracts
-
-public interface IAudioTranscoderService
 {
-    public Task<AudioTranscodeResult> TranscodeToAudioFileAsync(Stream audioStream, string destinationPath, CancellationToken cancellationToken);
+    public interface IAudioTranscoderService
+    {
+        Task<AudioTranscodeResult> TranscodeToAudioFileAsync(Stream audioStream, string destinationPath, CancellationToken cancellationToken);
+
+        Task<bool> IsValidAudioFileAsync(string filePath, CancellationToken cancellationToken);
+    }
 }

backend/Core/Musify.Application/Contracts/IDatabase.cs

@@ -1,40 +1,42 @@
-using ErrorOr;
 using Microsoft.EntityFrameworkCore;
 using Musify.Domain.Entities;
 
-namespace Musify.Application.Contracts;
+namespace Musify.Application.Contracts
-
-public interface IDatabase
 {
-    public DbSet<User> Users { get; }
+    public interface IDatabase
+    {
+        DbSet<User> Users { get; }
 
-    public DbSet<PlayList> PlayLists { get; }
+        DbSet<PlayList> PlayLists { get; }
 
-    public DbSet<Album> Albums { get; }
+        DbSet<Album> Albums { get; }
 
-    public DbSet<AlbumHasTrack> AlbumHasTracks { get; }
+        DbSet<AlbumHasTrack> AlbumHasTracks { get; }
 
-    public DbSet<Track> Tracks { get; }
+        DbSet<Track> Tracks { get; }
 
-    public DbSet<PlayListHasTrack> PlayListHasTracks { get; }
+        DbSet<UserHasTrack> UserHasTracks { get; }
 
-    public DbSet<Mix> Mixes { get; }
+        DbSet<PlayListHasTrack> PlayListHasTracks { get; }
 
-    public DbSet<MixItem> MixItems { get; }
+        DbSet<Mix> Mixes { get; }
 
-    public DbSet<UploadIntent> UploadIntents { get; }
+        DbSet<MixItem> MixItems { get; }
 
-    public DbSet<ListeningHistory> ListeningHistories { get; }
+        DbSet<Upload> Uploads { get; }
 
-    public DbSet<TrackLike> TrackLikes { get; }
+        DbSet<UploadIntent> UploadIntents { get; }
 
-    public DbSet<TrackTag> TrackTags { get; }
+        DbSet<ListeningHistory> ListeningHistories { get; }
 
-    public DbSet<UserFollow> UserFollows { get; }
+        DbSet<TrackLike> TrackLikes { get; }
 
-    public Task<IDatabaseTransaction> BeginTransactionAsync(System.Data.IsolationLevel isolationLevel, CancellationToken cancellationToken);
+        DbSet<TrackTag> TrackTags { get; }
 
-    public Task<int> SaveChangesAsync(CancellationToken cancellationToken);
+        DbSet<UserFollow> UserFollows { get; }
 
-    public Task<ErrorOr<Success>> TrySaveChangesAsync(Error onUniqueViolation, CancellationToken cancellationToken);
+        Task<IDatabaseTransaction> BeginTransactionAsync(System.Data.IsolationLevel isolationLevel, CancellationToken cancellationToken);
+
+        Task<int> SaveChangesAsync(CancellationToken cancellationToken);
+    }
 }

backend/Core/Musify.Application/Contracts/IDatabaseTransaction.cs

@@ -1,6 +1,7 @@
-namespace Musify.Application.Contracts;
+namespace Musify.Application.Contracts
-
-public interface IDatabaseTransaction : IAsyncDisposable
 {
-    public Task CommitAsync(CancellationToken cancellationToken = default);
+    public interface IDatabaseTransaction : IAsyncDisposable
+    {
+        Task CommitAsync(CancellationToken cancellationToken = default);
+    }
 }

backend/Core/Musify.Application/Contracts/IEventBus.cs

@@ -1,6 +1,7 @@
-namespace Musify.Application.Contracts;
+namespace Musify.Application.Contracts
-
-public interface IEventBus
 {
-    public Task PublishAsync<T>(T message, CancellationToken cancellationToken) where T : class;
+    public interface IEventBus
+    {
+        Task PublishAsync<T>(T message, CancellationToken cancellationToken) where T : class;
+    }
 }

backend/Core/Musify.Application/Contracts/IPictureService.cs

@@ -1,6 +1,7 @@
-namespace Musify.Application.Contracts;
+namespace Musify.Application.Contracts
-
-public interface IPictureService
 {
-    public Task<Stream> ResizePictureAsWebpAsync(Stream pictureStream, int width, int height, CancellationToken cancellationToken);
+    public interface IPictureService
+    {
+        Task<Stream> ResizePictureAsWebpAsync(Stream pictureStream, int width, int height, CancellationToken cancellationToken);
+    }
 }

backend/Core/Musify.Application/Contracts/IStorageService.cs

@@ -1,24 +1,28 @@
-namespace Musify.Application.Contracts;
+namespace Musify.Application.Contracts
-
-public interface IStorageService
 {
-    /// <summary>Opens an object for reading, or returns null when it does not exist.</summary>
+    public interface IStorageService
-    public Task<Stream?> GetFileAsync(string bucket, string key, CancellationToken cancellationToken);
+    {
+        Task<Stream> GetFileAsync(string bucket, string key, CancellationToken cancellationToken);
 
-    public Task<ObjectMetaData?> HeadObjectAsync(string bucket, string key, CancellationToken cancellationToken);
+        Task<ObjectMetaData?> HeadObjectAsync(string bucket, string key, CancellationToken cancellationToken);
 
-    public Task<string> GetUploadUrlAsync(string bucket, string key, string contentType, TimeSpan expirationTime, bool preventOverwrite = true, CancellationToken cancellationToken = default);
+        Task<string> GetUrlAsync(string bucket, string key, TimeSpan ExpirationTime, CancellationToken cancellationToken);
 
-    public Task UploadFileAsync(string filePath, string bucket, string key, CancellationToken cancellationToken);
+        Task<string> GetUploadUrlAsync(string bucket, string key, string contentType, TimeSpan expirationTime, CancellationToken cancellationToken, bool preventOverwrite = true);
 
-    public Task UploadFileAsync(Stream sourceStream, string contentType, string bucket, string key, CancellationToken cancellationToken);
+        Task UploadFileAsync(string filePath, string bucket, string key, CancellationToken cancellationToken);
 
-    public Task<IReadOnlyList<string>> TransferFilesAsync(string sourceDirectory, string bucket, string route, CancellationToken cancellationToken);
+        Task UploadFileAsync(Stream sourceStream, string contentType, string bucket, string key, CancellationToken cancellationToken);
 
-    public Task RemoveFileAsync(string bucket, string key, CancellationToken cancellationToken);
+        Task<IReadOnlyList<string>> TransferFilesAsync(string sourceDirectory, string bucket, string route, CancellationToken cancellationToken);
 
-    public Task CopyFileAsync(string sourceBucket, string sourceKey, string destinationBucket, string destinationKey,
+        Task RemoveFileAsync(string bucket, string key, CancellationToken cancellationToken);
-        CancellationToken cancellationToken);
 
-    public IAsyncEnumerable<StorageObject> ListObjectsAsync(string bucket, string prefix, CancellationToken cancellationToken);
+        Task CopyFileAsync(string sourceBucket, string sourceKey, string destinationBucket, string destinationKey,
+            CancellationToken cancellationToken);
+
+        Task RemoveFolderAsync(string bucket, string folderKey, CancellationToken cancellationToken);
+        
+        IAsyncEnumerable<StorageObject> ListObjectsAsync(string bucket, string prefix, CancellationToken cancellationToken);
+    }
 }

backend/Core/Musify.Application/Contracts/IStreamTicketService.cs

@@ -1,8 +1,10 @@
-namespace Musify.Application.Contracts;
+namespace Musify.Application.Contracts
-
-public interface IStreamTicketService
 {
-    public StreamTicket IssueTicket(long? userId, string keyPrefix, long? maxBytes = null);
+    public interface IStreamTicketService
-}
+    {
 
-public record StreamTicket(string Token, int ExpiresInSeconds);
+        StreamTicket IssueTicket(long? userId, string keyPrefix, long? maxBytes = null);
+    }
+
+    public record StreamTicket(string Token, int ExpiresInSeconds);
+}

backend/Core/Musify.Application/Contracts/ObjectMetaData.cs

@@ -1,3 +1,4 @@
-namespace Musify.Application.Contracts;
+namespace Musify.Application.Contracts
-
+{
-public record ObjectMetaData(string ContentType, long ContentLength);
+    public record ObjectMetaData(string ContentType, long ContentLength);
+}

backend/Core/Musify.Application/Contracts/StorageObject.cs

@@ -1,3 +1,4 @@
-namespace Musify.Application.Contracts;
+namespace Musify.Application.Contracts
-
+{
-public record StorageObject(string Key, DateTime LastModifiedUtc);
+    public record StorageObject(string Key, DateTime LastModifiedUtc);
+}

backend/Core/Musify.Application/Events/AlbumPictureProcessed.cs

@@ -1,3 +1,4 @@
-namespace Musify.Application.Events;
+namespace Musify.Application.Events
-
+{
-public record AlbumPictureProcessed(Guid AlbumId);
+    public record AlbumPictureProcessed(Guid AlbumId);
+}

backend/Core/Musify.Application/Events/AlbumPictureProcessingFailed.cs

@@ -1,3 +1,4 @@
-namespace Musify.Application.Events;
+namespace Musify.Application.Events
-
+{
-public record AlbumPictureProcessingFailed(Guid AlbumId);
+    public record AlbumPictureProcessingFailed(Guid AlbumId);
+}

backend/Core/Musify.Application/Events/AlbumProcessingFailed.cs

@@ -1,6 +1,7 @@
-namespace Musify.Application.Events;
+namespace Musify.Application.Events
-
+{
-public record AlbumProcessingFailed(
+    public record AlbumProcessingFailed(
-    Guid AlbumId,
+        Guid AlbumId,
-    string? Bucket,
+        string? Bucket,
-    string? PictureKey);
+        string? PictureKey);
+}

backend/Core/Musify.Application/Events/CreateAlbumResourcesEvent.cs

@@ -1,11 +1,14 @@
 using Musify.Application.Shared;
 
-namespace Musify.Application.Events;
+namespace Musify.Application.Events
-
+{
-public record CreateAlbumResourcesEvent(
+    public record CreateAlbumResourcesEvent(
-    Guid AlbumId,
+        Guid AlbumId,
-    Guid PictureIntentId,
+        Guid PictureIntentId,
-    string Bucket,
+        string Bucket,
-    string PictureSourceKey,
+        string PictureSourceKey,
-    string PictureDestinationKey,
+        string PictureDestinationKey,
-    ImageSizes Sizes);
+        ImageSize Small,
+        ImageSize Medium,
+        ImageSize Large);
+}

backend/Core/Musify.Application/Events/CreatePlayListResourcesEvent.cs

@@ -1,11 +1,14 @@
 using Musify.Application.Shared;
 
-namespace Musify.Application.Events;
+namespace Musify.Application.Events
-
+{
-public record CreatePlayListResourcesEvent(
+    public record CreatePlayListResourcesEvent(
-    Guid PlayListId,
+        Guid PlayListId,
-    Guid PictureIntentId,
+        Guid PictureIntentId,
-    string Bucket,
+        string Bucket,
-    string PictureSourceKey,
+        string PictureSourceKey,
-    string PictureDestinationKey,
+        string PictureDestinationKey,
-    ImageSizes Sizes);
+        ImageSize Small,
+        ImageSize Medium,
+        ImageSize Large);
+}

backend/Core/Musify.Application/Events/CreateTrackResourcesEvent.cs

@@ -1,15 +1,18 @@
 using Musify.Application.Shared;
 
-namespace Musify.Application.Events;
+namespace Musify.Application.Events
-
+{
-public record CreateTrackResourcesEvent(
+    public record CreateTrackResourcesEvent(
-    Guid TrackId,
+        Guid TrackId,
-    Guid PictureIntentId,
+        Guid PictureIntentId,
-    Guid AudioIntentId,
+        Guid AudioIntentId,
-    string Bucket,
+        string Bucket,
-    string PictureSourceKey,
+        string PictureSourceKey,
-    string PictureDestinationKey,
+        string PictureDestinationKey,
-    string AudioSourceKey,
+        string AudioSourceKey,
-    string AudioDestinationKey,
+        string AudioDestinationKey,
-    string AudioProcessedFolderKey,
+        string AudioProcessedFolderKey,
-    ImageSizes Sizes);
+        ImageSize Small,
+        ImageSize Medium,
+        ImageSize Large);
+}

backend/Core/Musify.Application/Events/DeleteAlbumEvent.cs

@@ -1,5 +0,0 @@
-namespace Musify.Application.Events;
-
-public record DeleteAlbumEvent(
-    Guid AlbumId,
-    long UserId);

backend/Core/Musify.Application/Events/DeletePlayListEvent.cs

@@ -1,5 +1,6 @@
-namespace Musify.Application.Events;
+namespace Musify.Application.Events
-
+{
-public record DeletePlayListEvent(
+    public record DeletePlayListEvent(
-    Guid PlayListId,
+        Guid PlayListId,
-    long UserId);
+        long UserId);
+}

backend/Core/Musify.Application/Events/DeleteTrackEvent.cs

@@ -1,5 +1,6 @@
-namespace Musify.Application.Events;
+namespace Musify.Application.Events
-
+{
-public record DeleteTrackEvent(
+    public record DeleteTrackEvent(
-    Guid TrackId,
+        Guid TrackId,
-    long UserId);
+        long UserId);
+}

backend/Core/Musify.Application/Events/PlayListPictureProcessed.cs

@@ -1,3 +1,4 @@
-namespace Musify.Application.Events;
+namespace Musify.Application.Events
-
+{
-public record PlayListPictureProcessed(Guid PlayListId);
+    public record PlayListPictureProcessed(Guid PlayListId);
+}

backend/Core/Musify.Application/Events/PlayListPictureProcessingFailed.cs

@@ -1,3 +1,4 @@
-namespace Musify.Application.Events;
+namespace Musify.Application.Events
-
+{
-public record PlayListPictureProcessingFailed(Guid PlayListId);
+    public record PlayListPictureProcessingFailed(Guid PlayListId);
+}

backend/Core/Musify.Application/Events/PlayListProcessingFailed.cs

@@ -1,6 +1,7 @@
-namespace Musify.Application.Events;
+namespace Musify.Application.Events
-
+{
-public record PlayListProcessingFailed(
+    public record PlayListProcessingFailed(
-    Guid PlayListId,
+        Guid PlayListId,
-    string? Bucket,
+        string? Bucket,
-    string? PictureKey);
+        string? PictureKey);
+}

backend/Core/Musify.Application/Events/TrackAudioProcessed.cs

@@ -1,3 +1,4 @@
-namespace Musify.Application.Events;
+namespace Musify.Application.Events
-
+{
-public record TrackAudioProcessed(Guid TrackId);
+    public record TrackAudioProcessed(Guid TrackId);
+}

backend/Core/Musify.Application/Events/TrackAudioProcessingFailed.cs

@@ -1,3 +1,4 @@
-namespace Musify.Application.Events;
+namespace Musify.Application.Events
-
+{
-public record TrackAudioProcessingFailed(Guid TrackId);
+    public record TrackAudioProcessingFailed(Guid TrackId);
+}

backend/Core/Musify.Application/Events/TrackPictureProcessed.cs

@@ -1,3 +1,4 @@
-namespace Musify.Application.Events;
+namespace Musify.Application.Events
-
+{
-public record TrackPictureProcessed(Guid TrackId);
+    public record TrackPictureProcessed(Guid TrackId);
+}

backend/Core/Musify.Application/Events/TrackPictureProcessingFailed.cs

@@ -1,3 +1,4 @@
-namespace Musify.Application.Events;
+namespace Musify.Application.Events
-
+{
-public record TrackPictureProcessingFailed(Guid TrackId);
+    public record TrackPictureProcessingFailed(Guid TrackId);
+}

backend/Core/Musify.Application/Events/TrackProcessingFailed.cs

@@ -1,7 +1,8 @@
-namespace Musify.Application.Events;
+namespace Musify.Application.Events
-
+{
-public record TrackProcessingFailed(
+    public record TrackProcessingFailed(
-    Guid TrackId,
+        Guid TrackId,
-    string? Bucket,
+        string? Bucket,
-    string? PictureKey,
+        string? PictureKey,
-    string? AudioKey);
+        string? AudioKey);
+}

backend/Core/Musify.Application/Events/UpdateAlbumPictureEvent.cs

@@ -1,9 +1,12 @@
 using Musify.Application.Shared;
 
-namespace Musify.Application.Events;
+namespace Musify.Application.Events
-
+{
-public record UpdateAlbumPictureEvent(
+    public record UpdateAlbumPictureEvent(
-    Guid AlbumId,
+        Guid AlbumId,
-    string Bucket,
+        string Bucket,
-    string SourceKey,
+        string SourceKey,
-    ImageSizes Sizes);
+        ImageSize Small,
+        ImageSize Medium,
+        ImageSize Large);
+}

backend/Core/Musify.Application/Events/UpdateAlbumPictureSourceEvent.cs

@@ -1,11 +1,14 @@
 using Musify.Application.Shared;
 
-namespace Musify.Application.Events;
+namespace Musify.Application.Events
-
+{
-public record UpdateAlbumPictureSourceEvent(
+    public record UpdateAlbumPictureSourceEvent(
-    Guid AlbumId,
+        Guid AlbumId,
-    Guid PictureIntentId,
+        Guid PictureIntentId,
-    string Bucket,
+        string Bucket,
-    string PictureSourceKey,
+        string PictureSourceKey,
-    string PictureDestinationKey,
+        string PictureDestinationKey,
-    ImageSizes Sizes);
+        ImageSize Small,
+        ImageSize Medium,
+        ImageSize Large);
+}

backend/Core/Musify.Application/Events/UpdatePlayListPictureEvent.cs

@@ -1,9 +1,12 @@
 using Musify.Application.Shared;
 
-namespace Musify.Application.Events;
+namespace Musify.Application.Events
-
+{
-public record UpdatePlayListPictureEvent(
+    public record UpdatePlayListPictureEvent(
-    Guid PlayListId,
+        Guid PlayListId,
-    string Bucket,
+        string Bucket,
-    string SourceKey,
+        string SourceKey,
-    ImageSizes Sizes);
+        ImageSize Small,
+        ImageSize Medium,
+        ImageSize Large);
+}

backend/Core/Musify.Application/Events/UpdatePlayListPictureSourceEvent.cs

@@ -1,11 +1,14 @@
 using Musify.Application.Shared;
 
-namespace Musify.Application.Events;
+namespace Musify.Application.Events
-
+{
-public record UpdatePlayListPictureSourceEvent(
+    public record UpdatePlayListPictureSourceEvent(
-    Guid PlayListId,
+        Guid PlayListId,
-    Guid PictureIntentId,
+        Guid PictureIntentId,
-    string Bucket,
+        string Bucket,
-    string PictureSourceKey,
+        string PictureSourceKey,
-    string PictureDestinationKey,
+        string PictureDestinationKey,
-    ImageSizes Sizes);
+        ImageSize Small,
+        ImageSize Medium,
+        ImageSize Large);
+}

backend/Core/Musify.Application/Events/UpdateTrackAudioEvent.cs

@@ -1,8 +1,9 @@
-namespace Musify.Application.Events;
+namespace Musify.Application.Events
-
+{
-public record UpdateTrackAudioEvent(
+    public record UpdateTrackAudioEvent(
-    Guid TrackId,
+        Guid TrackId,
-    string SourceBucket,
+        string SourceBucket,
-    string SourceKey,
+        string SourceKey,
-    string DestinationBucket,
+        string DestinationBucket,
-    string DestinationFolderKey);
+        string DestinationFolderKey);
+}

backend/Core/Musify.Application/Events/UpdateTrackPictureEvent.cs

@@ -1,9 +1,12 @@
 using Musify.Application.Shared;
 
-namespace Musify.Application.Events;
+namespace Musify.Application.Events
-
+{
-public record UpdateTrackPictureEvent(
+    public record UpdateTrackPictureEvent(
-    Guid TrackId,
+        Guid TrackId,
-    string Bucket,
+        string Bucket,
-    string SourceKey,
+        string SourceKey,
-    ImageSizes Sizes);
+        ImageSize Small,
+        ImageSize Medium,
+        ImageSize Large);
+}

backend/Core/Musify.Application/Genres/GetAvailableGenres.cs

@@ -1,24 +1,26 @@
 using Mediator;
 using Musify.Domain.ValueObjects;
-using Musify.Application.Genres.Responses;
 
-namespace Musify.Application.Genres;
+namespace Musify.Application.Genres
-
-public record GetAvailableGenresQuery : IQuery<IReadOnlyList<AvailableGenreResponse>>;
-
-public class GetAvailableGenresQueryHandler
-    : IQueryHandler<GetAvailableGenresQuery, IReadOnlyList<AvailableGenreResponse>>
 {
-    public ValueTask<IReadOnlyList<AvailableGenreResponse>> Handle(GetAvailableGenresQuery request, CancellationToken cancellationToken)
+    public record GetAvailableGenresQuery : IQuery<IReadOnlyList<AvailableGenreResponse>>;
+
+    public record AvailableGenreResponse(Genre Genre, IReadOnlyList<Genre> IncompatibleWith);
+
+    public class GetAvailableGenresQueryHandler
+        : IQueryHandler<GetAvailableGenresQuery, IReadOnlyList<AvailableGenreResponse>>
     {
-        var all = Enum.GetValues<Genre>();
+        public ValueTask<IReadOnlyList<AvailableGenreResponse>> Handle(GetAvailableGenresQuery request, CancellationToken cancellationToken)
+        {
+            var all = Enum.GetValues<Genre>();
 
-        IReadOnlyList<AvailableGenreResponse> result = all
+            IReadOnlyList<AvailableGenreResponse> result = all
-            .Select(genre => new AvailableGenreResponse(
+                .Select(genre => new AvailableGenreResponse(
-                genre,
+                    genre,
-                all.Where(other => !GenreCompatibility.AreCompatible(genre, other)).ToList()))
+                    all.Where(other => !GenreCompatibility.AreCompatible(genre, other)).ToList()))
-            .ToList();
+                .ToList();
 
-        return ValueTask.FromResult(result);
+            return ValueTask.FromResult(result);
+        }
     }
 }

backend/Core/Musify.Application/Genres/GetGenres.cs

@@ -2,28 +2,30 @@ using Mediator;
 using Microsoft.EntityFrameworkCore;
 using Musify.Application.Contracts;
 using Musify.Domain.ValueObjects;
-using Musify.Application.Genres.Responses;
 
-namespace Musify.Application.Genres;
+namespace Musify.Application.Genres
-
-public record GetGenresQuery : IQuery<IReadOnlyList<GenreResponse>>;
-
-public class GetGenresQueryHandler(IDatabase database)
-    : IQueryHandler<GetGenresQuery, IReadOnlyList<GenreResponse>>
 {
-    public async ValueTask<IReadOnlyList<GenreResponse>> Handle(GetGenresQuery request, CancellationToken cancellationToken)
+    public record GetGenresQuery : IQuery<IReadOnlyList<GenreResponse>>;
-    {
-        var rows = await database.TrackTags
-            .AsNoTracking()
-            .Where(tag => tag.Track.LifeCycleStatus == LifeCycleStatus.Active)
-            .GroupBy(tag => tag.Tag)
-            .Select(group => new { Genre = group.Key, TrackCount = group.Select(tag => tag.TrackId).Distinct().Count() })
-            .ToListAsync(cancellationToken);
 
-        return rows
+    public record GenreResponse(Genre Genre, int TrackCount);
-            .OrderByDescending(row => row.TrackCount)
+
-            .ThenBy(row => row.Genre)
+    public class GetGenresQueryHandler(IDatabase database)
-            .Select(row => new GenreResponse(row.Genre, row.TrackCount))
+        : IQueryHandler<GetGenresQuery, IReadOnlyList<GenreResponse>>
-            .ToList();
+    {
+        public async ValueTask<IReadOnlyList<GenreResponse>> Handle(GetGenresQuery request, CancellationToken cancellationToken)
+        {
+            var rows = await database.TrackTags
+                .AsNoTracking()
+                .Where(tag => database.UserHasTracks.Any(userTrack => userTrack.TrackId == tag.TrackId))
+                .GroupBy(tag => tag.Tag)
+                .Select(group => new { Genre = group.Key, TrackCount = group.Select(tag => tag.TrackId).Distinct().Count() })
+                .ToListAsync(cancellationToken);
+
+            return rows
+                .OrderByDescending(row => row.TrackCount)
+                .ThenBy(row => row.Genre)
+                .Select(row => new GenreResponse(row.Genre, row.TrackCount))
+                .ToList();
+        }
     }
 }

backend/Core/Musify.Application/Genres/Responses/AvailableGenreResponse.cs

@@ -1,5 +0,0 @@
-using Musify.Domain.ValueObjects;
-
-namespace Musify.Application.Genres.Responses;
-
-public record AvailableGenreResponse(Genre Genre, IReadOnlyList<Genre> IncompatibleWith);

backend/Core/Musify.Application/Genres/Responses/GenreResponse.cs

@@ -1,5 +0,0 @@
-using Musify.Domain.ValueObjects;
-
-namespace Musify.Application.Genres.Responses;
-
-public record GenreResponse(Genre Genre, int TrackCount);

backend/Core/Musify.Application/Likes/GetLikedTracks.cs

@@ -1,30 +1,43 @@
+using ErrorOr;
 using Mediator;
 using Microsoft.EntityFrameworkCore;
 using Musify.Application.Contracts;
 using Musify.Application.Shared;
 using Musify.Application.Tracks.Responses;
-using Musify.Domain.ValueObjects;
+using X.PagedList;
+using X.PagedList.EF;
 
-namespace Musify.Application.Likes;
+namespace Musify.Application.Likes
-
-public record GetLikedTracksQuery(
-    long UserId,
-    int PageNumber,
-    int PageSize)
-    : IQuery<PaginatedResponse<TrackApplicationResponse>>;
-
-public class GetLikedTracksQueryHandler(IDatabase database)
-    : IQueryHandler<GetLikedTracksQuery, PaginatedResponse<TrackApplicationResponse>>
 {
-    public async ValueTask<PaginatedResponse<TrackApplicationResponse>> Handle(GetLikedTracksQuery request, CancellationToken cancellationToken)
+    public record GetLikedTracksQuery(
+        long UserId,
+        int PageNumber,
+        int PageSize)
+        : IQuery<ErrorOr<PaginatedResponse<TrackApplicationResponse>>>;
+
+    public class GetLikedTracksQueryHandler(IDatabase database)
+        : IQueryHandler<GetLikedTracksQuery, ErrorOr<PaginatedResponse<TrackApplicationResponse>>>
     {
-        return await database.TrackLikes
+        public async ValueTask<ErrorOr<PaginatedResponse<TrackApplicationResponse>>> Handle(GetLikedTracksQuery request, CancellationToken cancellationToken)
-            .AsNoTracking()
+        {
-            .Where(like => like.UserId == request.UserId && like.Track.LifeCycleStatus == LifeCycleStatus.Active)
+            var likesQuery = database.TrackLikes
-            .OrderByDescending(like => like.CreatedAt)
+                .AsNoTracking()
-            .ThenBy(like => like.Id)
+                .Include(like => like.Track.Owner)
-            .Select(like => like.Track)
+                .Include(like => like.Track.Tags)
-            .SelectResponse()
+                .Where(like => like.UserId == request.UserId);
-            .ToPaginatedAsync(new PageRequest(request.PageNumber, request.PageSize), cancellationToken);
+
+            var totalCount = await likesQuery.CountAsync(cancellationToken);
+
+            var pagedEntities = await likesQuery
+                .OrderByDescending(like => like.CreatedAt)
+                .Select(like => new { like.Track, ListensCount = like.Track.ListeningHistories.Count(l => l.IsCounted) })
+                .ToPagedListAsync(request.PageNumber, request.PageSize, totalCount, cancellationToken);
+
+            var pagedTracks = new StaticPagedList<TrackApplicationResponse>(
+                pagedEntities.Select(x => TrackApplicationResponse.FromEntity(x.Track, x.ListensCount)),
+                pagedEntities.PageNumber, pagedEntities.PageSize, pagedEntities.TotalItemCount);
+
+            return PaginatedResponse<TrackApplicationResponse>.FromPagedList(pagedTracks);
+        }
     }
 }

backend/Core/Musify.Application/Likes/ToggleTrackLike.cs

@@ -3,56 +3,54 @@ using Mediator;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.Logging;
 using Musify.Application.Contracts;
-using Musify.Application.Shared;
 using Musify.Domain.Entities;
-using Musify.Domain.ValueObjects;
 
-namespace Musify.Application.Likes;
+namespace Musify.Application.Likes
-
-public record ToggleTrackLikeCommand(long UserId, Guid TrackId)
-    : ICommand<ErrorOr<bool>>;
-
-public class ToggleTrackLikeCommandHandler(
-    IDatabase database,
-    ILogger<ToggleTrackLikeCommandHandler> logger)
-    : ICommandHandler<ToggleTrackLikeCommand, ErrorOr<bool>>
 {
-    public async ValueTask<ErrorOr<bool>> Handle(ToggleTrackLikeCommand request, CancellationToken cancellationToken)
+    public record ToggleTrackLikeCommand(long UserId, Guid TrackId)
+        : ICommand<ErrorOr<bool>>;
+
+    public class ToggleTrackLikeCommandHandler(
+        IDatabase database,
+        ILogger<ToggleTrackLikeCommandHandler> logger)
+        : ICommandHandler<ToggleTrackLikeCommand, ErrorOr<bool>>
     {
-        var trackExists = await database.Tracks
+        public async ValueTask<ErrorOr<bool>> Handle(ToggleTrackLikeCommand request, CancellationToken cancellationToken)
-            .AsNoTracking()
-            .AnyAsync(t => t.Id == request.TrackId && t.LifeCycleStatus == LifeCycleStatus.Active, cancellationToken);
-        if (!trackExists)
-            return AppErrors.NotFound("Track", request.TrackId);
-
-        var existingLike = await database.TrackLikes
-            .SingleOrDefaultAsync(like => like.UserId == request.UserId && like.TrackId == request.TrackId, cancellationToken);
-
-        bool nowLiked;
-        if (existingLike != null)
         {
-            database.TrackLikes.Remove(existingLike);
+            var trackExists = await database.Tracks
-            nowLiked = false;
+                .AsNoTracking()
-        }
+                .AnyAsync(t => t.Id == request.TrackId, cancellationToken);
-        else
+            if (!trackExists)
-        {
-            await database.TrackLikes.AddAsync(new TrackLike
             {
-                UserId = request.UserId,
+                logger.LogInformation("Track {TrackId} not found", request.TrackId);
-                TrackId = request.TrackId
+                return Error.NotFound(description: $"Track {request.TrackId} not found");
-            }, cancellationToken);
+            }
-            nowLiked = true;
+
+            var existingLike = await database.TrackLikes
+                .SingleOrDefaultAsync(like => like.UserId == request.UserId && like.TrackId == request.TrackId, cancellationToken);
+
+            bool nowLiked;
+            if (existingLike != null)
+            {
+                database.TrackLikes.Remove(existingLike);
+                nowLiked = false;
+            }
+            else
+            {
+                await database.TrackLikes.AddAsync(new TrackLike
+                {
+                    UserId = request.UserId,
+                    TrackId = request.TrackId
+                }, cancellationToken);
+                nowLiked = true;
+            }
+
+            await database.SaveChangesAsync(cancellationToken);
+
+            logger.LogInformation("User {UserId} {Action} track {TrackId}",
+                request.UserId, nowLiked ? "liked" : "unliked", request.TrackId);
+
+            return nowLiked;
         }
-
-        // A concurrent double click can hit the unique index; the outcome is already in place, so treat it as a no-op.
-        var saved = await database.TrySaveChangesAsync(
-            AppErrors.Conflict("TrackLike.Duplicate", "Track is already liked."), cancellationToken);
-        if (saved.IsError)
-            return true;
-
-        logger.LogInformation("User {UserId} {Action} track {TrackId}",
-            request.UserId, nowLiked ? "liked" : "unliked", request.TrackId);
-
-        return nowLiked;
     }
 }

backend/Core/Musify.Application/Mixes/GenerateMixesForUser.cs

@@ -1,3 +1,4 @@
+using ErrorOr;
 using Mediator;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.Logging;
@@ -6,124 +7,146 @@ using Musify.Application.Contracts;
 using Musify.Domain.Entities;
 using Musify.Domain.ValueObjects;
 
-namespace Musify.Application.Mixes;
+namespace Musify.Application.Mixes
-
-public record GenerateMixesForUserCommand(long UserId)
-    : ICommand;
-
-public class GenerateMixesForUserCommandHandler(
-    IDatabase database,
-    MixConfiguration mixConfiguration,
-    ILogger<GenerateMixesForUserCommandHandler> logger)
-    : ICommandHandler<GenerateMixesForUserCommand>
 {
-    private sealed record MixDraft(MixKind Kind, IReadOnlyList<Guid> TrackIds);
+    public record GenerateMixesForUserCommand(long UserId)
+        : ICommand<ErrorOr<Success>>;
 
-    public async ValueTask<Unit> Handle(GenerateMixesForUserCommand request, CancellationToken cancellationToken)
+    public class GenerateMixesForUserCommandHandler(
+        IDatabase database,
+        MixConfiguration mixConfiguration,
+        ILogger<GenerateMixesForUserCommandHandler> logger)
+        : ICommandHandler<GenerateMixesForUserCommand, ErrorOr<Success>>
     {
-        var userId = request.UserId;
+        private sealed record MixDraft(string Title, string? Subtitle, IReadOnlyList<Guid> TrackIds);
 
-        var libraryTrackIds = await database.Tracks
+        public async ValueTask<ErrorOr<Success>> Handle(GenerateMixesForUserCommand request, CancellationToken cancellationToken)
-            .AsNoTracking()
-            .Where(track => track.OwnerUserId == userId && track.LifeCycleStatus == LifeCycleStatus.Active)
-            .Select(track => track.Id)
-            .ToListAsync(cancellationToken);
-
-        if (libraryTrackIds.Count == 0)
         {
-            logger.LogInformation("User {UserId} has no tracks yet, skipping mix generation", userId);
+            var userId = request.UserId;
-            return Unit.Value;
-        }
 
-        var historyTrackIds = await database.ListeningHistories
+            var libraryTrackIds = await database.UserHasTracks
-            .AsNoTracking()
+                .AsNoTracking()
-            .Where(history => history.UserId == userId && history.IsCounted)
+                .Where(userTrack => userTrack.UserId == userId && userTrack.Track.LifeCycleStatus == LifeCycleStatus.Active)
-            .Select(history => history.TrackId)
+                .Select(userTrack => userTrack.TrackId)
-            .Distinct()
+                .ToListAsync(cancellationToken);
-            .ToListAsync(cancellationToken);
 
-        var historySet = new HashSet<Guid>(historyTrackIds);
+            if (libraryTrackIds.Count == 0)
-        var unheardTrackIds = libraryTrackIds.Where(id => !historySet.Contains(id)).ToList();
-
-        var drafts = new List<MixDraft>();
-
-        var discovery = Take(Shuffle(unheardTrackIds));
-        if (discovery.Count > 0)
-        {
-            drafts.Add(new MixDraft(MixKind.Discovery, discovery));
-        }
-
-        var daily = Take(Interleave(Shuffle(historyTrackIds), Shuffle(unheardTrackIds)));
-        if (daily.Count > 0)
-        {
-            drafts.Add(new MixDraft(MixKind.Daily, daily));
-        }
-
-        if (drafts.Count == 0)
-        {
-            logger.LogInformation("No candidate songs found for user {UserId}, skipping mix generation", userId);
-            return Unit.Value;
-        }
-
-        await ReplaceMixesAsync(userId, drafts, cancellationToken);
-
-        await database.SaveChangesAsync(cancellationToken);
-
-        logger.LogInformation("Generated {Count} mixes for user {UserId}", drafts.Count, userId);
-        return Unit.Value;
-    }
-
-    private List<Guid> Take(IEnumerable<Guid> trackIds) =>
-        [.. trackIds.Take(mixConfiguration.ItemsPerMix)];
-
-    private static List<Guid> Shuffle(IEnumerable<Guid> trackIds) =>
-        [.. trackIds.OrderBy(_ => Guid.NewGuid())];
-
-    private static List<Guid> Interleave(IReadOnlyList<Guid> first, IReadOnlyList<Guid> second)
-    {
-        var merged = new List<Guid>(first.Count + second.Count);
-        for (var index = 0; index < Math.Max(first.Count, second.Count); index++)
-        {
-            if (index < first.Count)
-                merged.Add(first[index]);
-            if (index < second.Count)
-                merged.Add(second[index]);
-        }
-
-        return merged;
-    }
-
-    private async Task ReplaceMixesAsync(long userId, IReadOnlyList<MixDraft> drafts, CancellationToken cancellationToken)
-    {
-        var previousMixes = await database.Mixes
-            .Where(mix => mix.UserId == userId)
-            .ToListAsync(cancellationToken);
-
-        if (previousMixes.Count > 0)
-        {
-            database.Mixes.RemoveRange(previousMixes);
-        }
-
-        for (var position = 0; position < drafts.Count; position++)
-        {
-            var draft = drafts[position];
-            var mix = new Mix
             {
-                UserId = userId,
+                logger.LogInformation("User {UserId} has no tracks yet, skipping mix generation", userId);
-                Kind = draft.Kind,
+                return new Success();
-                Position = position
+            }
-            };
 
-            await database.Mixes.AddAsync(mix, cancellationToken);
+            var historyTrackIds = await database.ListeningHistories
+                .AsNoTracking()
+                .Where(history => history.UserId == userId && history.IsCounted)
+                .Select(history => history.TrackId)
+                .Distinct()
+                .ToListAsync(cancellationToken);
 
-            for (var itemPosition = 0; itemPosition < draft.TrackIds.Count; itemPosition++)
+            var historySet = new HashSet<Guid>(historyTrackIds);
+            var unheardTrackIds = libraryTrackIds.Where(id => !historySet.Contains(id)).ToList();
+
+            var drafts = new List<MixDraft>();
+
+            var discovery = Take(Shuffle(unheardTrackIds));
+            if (discovery.Count > 0)
             {
-                await database.MixItems.AddAsync(new MixItem
+                drafts.Add(new MixDraft(
+                    "Descubrimiento",
+                    "Canciones de tu biblioteca que todavía no has escuchado.",
+                    discovery));
+            }
+
+            var daily = Take(Interleave(Shuffle(historyTrackIds), Shuffle(unheardTrackIds)));
+            if (daily.Count > 0)
+            {
+                drafts.Add(new MixDraft(
+                    "Tu mezcla diaria",
+                    "Lo que más escuchas, con alguna sorpresa de tu biblioteca.",
+                    daily));
+            }
+
+            if (drafts.Count == 0)
+            {
+                logger.LogInformation("No candidate songs found for user {UserId}, skipping mix generation", userId);
+                return new Success();
+            }
+
+            await ReplaceMixesAsync(userId, drafts, cancellationToken);
+
+            try
+            {
+                await database.SaveChangesAsync(cancellationToken);
+            }
+            catch (Exception exception)
+            {
+                logger.LogError(exception, "Failed to generate mixes for user {UserId}", userId);
+                return Error.Failure(description: $"Failed to generate mixes for user {userId}");
+            }
+
+            logger.LogInformation("Generated {Count} mixes for user {UserId}", drafts.Count, userId);
+            return new Success();
+        }
+
+        private List<Guid> Take(IEnumerable<Guid> trackIds) =>
+            [.. trackIds.Take(mixConfiguration.ItemsPerMix)];
+
+        private static List<Guid> Shuffle(IEnumerable<Guid> trackIds) =>
+            [.. trackIds.OrderBy(_ => Guid.NewGuid())];
+
+        private static List<Guid> Interleave(IReadOnlyList<Guid> first, IReadOnlyList<Guid> second)
+        {
+            var merged = new List<Guid>(first.Count + second.Count);
+            for (var index = 0; index < Math.Max(first.Count, second.Count); index++)
+            {
+                if (index < first.Count)
+                    merged.Add(first[index]);
+                if (index < second.Count)
+                    merged.Add(second[index]);
+            }
+
+            return merged;
+        }
+
+        private async Task ReplaceMixesAsync(long userId, IReadOnlyList<MixDraft> drafts, CancellationToken cancellationToken)
+        {
+            var previousMixes = await database.Mixes
+                .Where(mix => mix.UserId == userId)
+                .ToListAsync(cancellationToken);
+
+            if (previousMixes.Count > 0)
+            {
+                var previousIds = previousMixes.Select(mix => mix.Id).ToList();
+                var previousItems = await database.MixItems
+                    .Where(item => previousIds.Contains(item.MixId))
+                    .ToListAsync(cancellationToken);
+
+                database.MixItems.RemoveRange(previousItems);
+                database.Mixes.RemoveRange(previousMixes);
+            }
+
+            for (var position = 0; position < drafts.Count; position++)
+            {
+                var draft = drafts[position];
+                var mix = new Mix
                 {
-                    MixId = mix.Id,
+                    UserId = userId,
-                    Position = itemPosition,
+                    Title = draft.Title,
-                    TrackId = draft.TrackIds[itemPosition]
+                    Subtitle = draft.Subtitle,
-                }, cancellationToken);
+                    Position = position
+                };
+
+                await database.Mixes.AddAsync(mix, cancellationToken);
+
+                for (var itemPosition = 0; itemPosition < draft.TrackIds.Count; itemPosition++)
+                {
+                    await database.MixItems.AddAsync(new MixItem
+                    {
+                        MixId = mix.Id,
+                        Position = itemPosition,
+                        TrackId = draft.TrackIds[itemPosition]
+                    }, cancellationToken);
+                }
             }
         }
     }

backend/Core/Musify.Application/Mixes/GetMixById.cs

@@ -3,29 +3,29 @@ using Mediator;
 using Microsoft.EntityFrameworkCore;
 using Musify.Application.Contracts;
 using Musify.Application.Mixes.Responses;
-using Musify.Application.Shared;
 
-namespace Musify.Application.Mixes;
+namespace Musify.Application.Mixes
-
-public record GetMixByIdQuery(long UserId, Guid MixId)
-    : IQuery<ErrorOr<MixApplicationResponse>>;
-
-public class GetMixByIdQueryHandler(IDatabase database)
-    : IQueryHandler<GetMixByIdQuery, ErrorOr<MixApplicationResponse>>
 {
-    public async ValueTask<ErrorOr<MixApplicationResponse>> Handle(GetMixByIdQuery request, CancellationToken cancellationToken)
+    public record GetMixByIdQuery(long UserId, Guid MixId)
+        : IQuery<ErrorOr<MixApplicationResponse>>;
+
+    public class GetMixByIdQueryHandler(IDatabase database)
+        : IQueryHandler<GetMixByIdQuery, ErrorOr<MixApplicationResponse>>
     {
-        var mix = await database.Mixes
+        public async ValueTask<ErrorOr<MixApplicationResponse>> Handle(GetMixByIdQuery request, CancellationToken cancellationToken)
-            .AsNoTracking()
+        {
-            .Include(mix => mix.Items)
+            var mix = await database.Mixes
-            .SingleOrDefaultAsync(mix => mix.Id == request.MixId && mix.UserId == request.UserId, cancellationToken);
+                .AsNoTracking()
+                .Include(mix => mix.Items)
+                .SingleOrDefaultAsync(mix => mix.Id == request.MixId && mix.UserId == request.UserId, cancellationToken);
 
-        if (mix == null)
+            if (mix == null)
-            return AppErrors.NotFound("Mix", request.MixId);
+                return Error.NotFound(description: $"Mix {request.MixId} was not found");
 
-        var orderedItems = mix.Items.OrderBy(item => item.Position).ToList();
+            var orderedItems = mix.Items.OrderBy(item => item.Position).ToList();
-        var items = await MixItemMapper.ToResponsesAsync(database, orderedItems, cancellationToken);
+            var items = await MixItemMapper.ToResponsesAsync(database, orderedItems, cancellationToken);
 
-        return new MixApplicationResponse(mix.Id, mix.Kind, items.Count, items);
+            return new MixApplicationResponse(mix.Id, mix.Title, mix.Subtitle, items.Count, items);
+        }
     }
 }

backend/Core/Musify.Application/Mixes/GetMixesByUserId.cs

@@ -1,50 +1,37 @@
+using ErrorOr;
 using Mediator;
 using Microsoft.EntityFrameworkCore;
 using Musify.Application.Contracts;
 using Musify.Application.Mixes.Responses;
 
-namespace Musify.Application.Mixes;
+namespace Musify.Application.Mixes
-
-public record GetMixesByUserIdQuery(long UserId)
-    : IQuery<IReadOnlyList<MixApplicationResponse>>;
-
-public class GetMixesByUserIdQueryHandler(IDatabase database)
-    : IQueryHandler<GetMixesByUserIdQuery, IReadOnlyList<MixApplicationResponse>>
 {
-    public async ValueTask<IReadOnlyList<MixApplicationResponse>> Handle(GetMixesByUserIdQuery request, CancellationToken cancellationToken)
+    public record GetMixesByUserIdQuery(long UserId)
+        : IQuery<ErrorOr<IReadOnlyList<MixApplicationResponse>>>;
+
+    public class GetMixesByUserIdQueryHandler(IDatabase database)
+        : IQueryHandler<GetMixesByUserIdQuery, ErrorOr<IReadOnlyList<MixApplicationResponse>>>
     {
-        var mixes = await database.Mixes
+        public async ValueTask<ErrorOr<IReadOnlyList<MixApplicationResponse>>> Handle(GetMixesByUserIdQuery request, CancellationToken cancellationToken)
-            .AsNoTracking()
-            .Where(mix => mix.UserId == request.UserId)
-            .Include(mix => mix.Items)
-            .OrderBy(mix => mix.Position)
-            .ThenBy(mix => mix.Id)
-            .ToListAsync(cancellationToken);
-
-        var orderedItemsByMix = mixes.ToDictionary(
-            mix => mix.Id,
-            mix => mix.Items.OrderBy(item => item.Position).ToList());
-
-        var coverItems = orderedItemsByMix.Values
-            .SelectMany(items => items.Take(MixApplicationResponse.CoverItemCount))
-            .ToList();
-        var coverResponses = (await MixItemMapper.ToResponsesAsync(database, coverItems, cancellationToken))
-            .GroupBy(response => response.TrackId)
-            .ToDictionary(group => group.Key, group => group.First());
-
-        var responses = new List<MixApplicationResponse>(mixes.Count);
-        foreach (var mix in mixes)
         {
-            var orderedItems = orderedItemsByMix[mix.Id];
+            var mixes = await database.Mixes
-            var covers = orderedItems
+                .AsNoTracking()
-                .Take(MixApplicationResponse.CoverItemCount)
+                .Where(mix => mix.UserId == request.UserId)
-                .Where(item => coverResponses.ContainsKey(item.TrackId))
+                .Include(mix => mix.Items)
-                .Select(item => coverResponses[item.TrackId])
+                .OrderBy(mix => mix.Position)
-                .ToList();
+                .ToListAsync(cancellationToken);
 
-            responses.Add(new MixApplicationResponse(mix.Id, mix.Kind, orderedItems.Count, covers));
+            var responses = new List<MixApplicationResponse>(mixes.Count);
+            foreach (var mix in mixes)
+            {
+                var orderedItems = mix.Items.OrderBy(item => item.Position).ToList();
+                var coverItems = await MixItemMapper.ToResponsesAsync(
+                    database, orderedItems.Take(MixApplicationResponse.CoverItemCount).ToList(), cancellationToken);
+
+                responses.Add(new MixApplicationResponse(mix.Id, mix.Title, mix.Subtitle, orderedItems.Count, coverItems));
+            }
+
+            return responses;
         }
-
-        return responses;
     }
 }

backend/Core/Musify.Application/Mixes/MixItemMapper.cs

@@ -2,39 +2,39 @@ using Microsoft.EntityFrameworkCore;
 using Musify.Application.Contracts;
 using Musify.Application.Mixes.Responses;
 using Musify.Domain.Entities;
-using Musify.Domain.ValueObjects;
 
-namespace Musify.Application.Mixes;
+namespace Musify.Application.Mixes
-
-
-internal static class MixItemMapper
 {
-    public static async Task<List<MixItemApplicationResponse>> ToResponsesAsync(
+
-        IDatabase database,
+    internal static class MixItemMapper
-        IReadOnlyList<MixItem> orderedItems,
-        CancellationToken cancellationToken)
     {
-        var trackIds = orderedItems.Select(item => item.TrackId).Distinct().ToList();
+        public static async Task<List<MixItemApplicationResponse>> ToResponsesAsync(
+            IDatabase database,
+            IReadOnlyList<MixItem> orderedItems,
+            CancellationToken cancellationToken)
+        {
+            var trackIds = orderedItems.Select(item => item.TrackId).Distinct().ToList();
 
-        var tracksById = await database.Tracks
+            var tracksById = await database.Tracks
-            .AsNoTracking()
+                .AsNoTracking()
-            .Include(track => track.Owner)
+                .Include(track => track.Owner)
-            .Where(track => trackIds.Contains(track.Id) && track.LifeCycleStatus == LifeCycleStatus.Active)
+                .Where(track => trackIds.Contains(track.Id))
-            .Select(track => new { Track = track, ListensCount = track.ListeningHistories.Count(l => l.IsCounted) })
+                .Select(track => new { Track = track, ListensCount = track.ListeningHistories.Count(l => l.IsCounted) })
-            .ToDictionaryAsync(x => x.Track.Id, cancellationToken);
+                .ToDictionaryAsync(x => x.Track.Id, cancellationToken);
 
-        return orderedItems
+            return orderedItems
-            .Where(item => tracksById.ContainsKey(item.TrackId))
+                .Where(item => tracksById.ContainsKey(item.TrackId))
-            .Select(item =>
+                .Select(item =>
-            {
+                {
-                var entry = tracksById[item.TrackId];
+                    var entry = tracksById[item.TrackId];
-                return new MixItemApplicationResponse(
+                    return new MixItemApplicationResponse(
-                    item.TrackId,
+                        item.TrackId,
-                    entry.Track.Title,
+                        entry.Track.Title,
-                    entry.Track.Owner.Name,
+                        entry.Track.Owner.Name,
-                    entry.Track.DurationSeconds,
+                        entry.Track.DurationSeconds,
-                    entry.ListensCount);
+                        entry.ListensCount);
-            })
+                })
-            .ToList();
+                .ToList();
+        }
     }
 }

backend/Core/Musify.Application/Mixes/Responses/MixApplicationResponse.cs

@@ -1,12 +1,12 @@
-using Musify.Domain.ValueObjects;
+namespace Musify.Application.Mixes.Responses
-
-namespace Musify.Application.Mixes.Responses;
-
-public record MixApplicationResponse(
-    Guid Id,
-    MixKind Kind,
-    int ItemCount,
-    IReadOnlyList<MixItemApplicationResponse> Items)
 {
-    public const int CoverItemCount = 4;
+    public record MixApplicationResponse(
+        Guid Id,
+        string Title,
+        string? Subtitle,
+        int ItemCount,
+        IReadOnlyList<MixItemApplicationResponse> Items)
+    {
+        public const int CoverItemCount = 4;
+    }
 }

backend/Core/Musify.Application/Mixes/Responses/MixItemApplicationResponse.cs

@@ -1,8 +1,9 @@
-namespace Musify.Application.Mixes.Responses;
+namespace Musify.Application.Mixes.Responses
-
+{
-public record MixItemApplicationResponse(
+    public record MixItemApplicationResponse(
-    Guid TrackId,
+        Guid TrackId,
-    string Title,
+        string Title,
-    string? Artist,
+        string? Artist,
-    double DurationSeconds,
+        double DurationSeconds,
-    int ListensCount);
+        int ListensCount);
+}

backend/Core/Musify.Application/Pictures/GetCover.cs

@@ -1,75 +0,0 @@
-using ErrorOr;
-using Mediator;
-using Microsoft.EntityFrameworkCore;
-using MimeMapping;
-using Musify.Application.Configuration;
-using Musify.Application.Contracts;
-using Musify.Application.Shared;
-using Musify.Domain.ValueObjects;
-
-namespace Musify.Application.Pictures;
-
-public enum CoverOwner
-{
-    Track,
-    Album,
-    PlayList
-}
-
-public record GetCoverQuery(CoverOwner Owner, Guid Id, PictureSize Size = PictureSize.Medium)
-    : IQuery<ErrorOr<CoverLocation>>;
-
-public record CoverLocation(string Bucket, string Key, string ContentType);
-
-public class GetCoverQueryHandler(
-    IDatabase database,
-    ApplicationStorageConfiguration storageConfiguration,
-    TrackConfiguration trackConfiguration,
-    AlbumConfiguration albumConfiguration,
-    PlayListConfiguration playListConfiguration)
-    : IQueryHandler<GetCoverQuery, ErrorOr<CoverLocation>>
-{
-    private sealed record CoverSource(long OwnerUserId, string? Original, string? Small, string? Medium, string? Large);
-
-    public async ValueTask<ErrorOr<CoverLocation>> Handle(GetCoverQuery request, CancellationToken cancellationToken)
-    {
-        var (source, routes) = request.Owner switch
-        {
-            CoverOwner.Track => (await database.Tracks.AsNoTracking()
-                .Where(t => t.Id == request.Id && t.LifeCycleStatus == LifeCycleStatus.Active)
-                .Select(t => new CoverSource(t.OwnerUserId, t.Pictures.OriginalName, t.Pictures.SmallName, t.Pictures.MediumName, t.Pictures.LargeName))
-                .SingleOrDefaultAsync(cancellationToken), trackConfiguration.Routes),
-            CoverOwner.Album => (await database.Albums.AsNoTracking()
-                .Where(a => a.Id == request.Id && a.LifeCycleStatus == LifeCycleStatus.Active && a.Pictures != null)
-                .Select(a => new CoverSource(a.OwnerUserId, a.Pictures!.OriginalName, a.Pictures.SmallName, a.Pictures.MediumName, a.Pictures.LargeName))
-                .SingleOrDefaultAsync(cancellationToken), albumConfiguration.Routes),
-            _ => (await database.PlayLists.AsNoTracking()
-                .Where(p => p.Id == request.Id && p.LifeCycleStatus == LifeCycleStatus.Active && p.Pictures != null)
-                .Select(p => new CoverSource(p.OwnerUserId, p.Pictures!.OriginalName, p.Pictures.SmallName, p.Pictures.MediumName, p.Pictures.LargeName))
-                .SingleOrDefaultAsync(cancellationToken), playListConfiguration.Routes)
-        };
-
-        var entity = request.Owner.ToString();
-        if (source == null)
-            return AppErrors.NotFound($"{entity}Cover", request.Id);
-
-        var resizedName = request.Size switch
-        {
-            PictureSize.Small => source.Small,
-            PictureSize.Large => source.Large,
-            _ => source.Medium
-        };
-
-        // The resized files only exist once processing has finished; until then serve the original.
-        var (name, key) = !string.IsNullOrEmpty(resizedName)
-            ? (resizedName, routes.BuildPicturePath(request.Size, resizedName))
-            : !string.IsNullOrEmpty(source.Original)
-                ? (source.Original, routes.BuildOriginalPicturePath(source.OwnerUserId, source.Original))
-                : (null, null);
-
-        if (name == null || key == null)
-            return AppErrors.NotFound($"{entity}Cover", request.Id);
-
-        return new CoverLocation(storageConfiguration.Bucket, key, MimeUtility.GetMimeMapping(name));
-    }
-}

backend/Core/Musify.Application/Pictures/PictureSourceChange.cs

@@ -1,35 +0,0 @@
-using ErrorOr;
-using Musify.Application.Configuration;
-using Musify.Application.Services;
-using Musify.Application.Shared;
-using Musify.Domain.Entities;
-using Musify.Domain.ValueObjects;
-
-namespace Musify.Application.Pictures;
-
-/// <summary>What an album or playlist needs to switch to a freshly uploaded picture.</summary>
-public sealed record PreparedPicture(UploadIntent Intent, EntityPictures Pictures, string FinalKey, ImageSizes Sizes);
-
-public static class PictureSourceChange
-{
-    public static async Task<ErrorOr<PreparedPicture>> PrepareAsync(
-        UploadIntentValidator uploadIntentValidator,
-        Guid intentId,
-        long userId,
-        UploadIntentPurpose purpose,
-        IPictureOwnerConfiguration owner,
-        CancellationToken cancellationToken)
-    {
-        var validation = await uploadIntentValidator.ValidateAndLoadAsync(intentId, userId, purpose, cancellationToken);
-        if (validation.IsError)
-            return validation.Errors;
-
-        var intent = validation.Value;
-
-        return new PreparedPicture(
-            intent,
-            EntityPictures.Pending(intent.ObjectName),
-            owner.Routes.BuildOriginalPicturePath(userId, intent.ObjectName),
-            owner.PicturesSizes.ToImageSizes(owner.Routes));
-    }
-}

backend/Core/Musify.Application/Pictures/Responses/PictureUploadResponse.cs

@@ -1,10 +0,0 @@
-namespace Musify.Application.Pictures.Responses;
-
-public record PictureUploadResponse(
-    Guid IntentId,
-    string Bucket,
-    string Key,
-    string PictureName,
-    string ContentType,
-    int ExpiresInSeconds,
-    string UploadUrl);

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

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

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

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

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

@@ -3,76 +3,144 @@ using Mediator;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.Logging;
 using Musify.Application.Configuration;
-using Musify.Application.Contracts;
+using Musify.Application.Shared;
 using Musify.Application.Events;
-using Musify.Application.Pictures;
 using Musify.Application.PlayLists.Responses;
 using Musify.Application.Services;
-using Musify.Application.Shared;
 using Musify.Domain.Entities;
 using Musify.Domain.ValueObjects;
+using Musify.Application.Contracts;
 
-namespace Musify.Application.PlayLists;
+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,
-    PlayListConfiguration playListConfiguration)
-    : ICommandHandler<CreatePlayListCommand, ErrorOr<PlayListApplicationResponse>>
 {
-    public async ValueTask<ErrorOr<PlayListApplicationResponse>> Handle(CreatePlayListCommand request, CancellationToken cancellationToken)
+    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>>
     {
-        var userExists = await database.Users
+        private sealed record ResolvedPlayListPictures(PlayListPictures? Pictures, UploadIntent? Intent);
-            .AsNoTracking()
-            .AnyAsync(u => u.Id == request.UserId, cancellationToken);
-        if (!userExists)
-            return AppErrors.NotFound("User", request.UserId);
 
-        PreparedPicture? picture = null;
+        public async ValueTask<ErrorOr<PlayListApplicationResponse>> Handle(CreatePlayListCommand request, CancellationToken cancellationToken)
-        if (request.PictureIntentId is { } intentId)
         {
-            var prepared = await PictureSourceChange.PrepareAsync(
+            var userExists = await database.Users
-                uploadIntentValidator, intentId, request.UserId, UploadIntentPurpose.PlayListPicture, playListConfiguration, cancellationToken);
+                .AsNoTracking()
-            if (prepared.IsError)
+                .AnyAsync(u => u.Id == request.UserId, cancellationToken);
-                return prepared.Errors;
+            if (!userExists)
+            {
+                logger.LogWarning("User {UserId} not found", request.UserId);
+                return Error.NotFound(description: $"User {request.UserId} not found");
+            }
 
-            picture = prepared.Value;
+            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);
         }
 
-        var name = request.Name.Trim();
+        private async ValueTask<ErrorOr<ResolvedPlayListPictures>> ResolvePicturesAsync(
-        var playList = new PlayList
+            CreatePlayListCommand request, CancellationToken cancellationToken)
         {
-            OwnerUserId = request.UserId,
+            if (!request.PictureIntentId.HasValue)
-            Name = name,
+            {
-            NormalizedName = TextNormalizer.Normalize(name),
+                return new ResolvedPlayListPictures(null, null);
-            Description = string.IsNullOrWhiteSpace(request.Description) ? null : request.Description.Trim(),
+            }
-            Pictures = picture?.Pictures,
-            Visibility = request.Visibility
-        };
-        await database.PlayLists.AddAsync(playList, cancellationToken);
 
-        if (picture != null)
+            var validation = await uploadIntentValidator.ValidateAndLoadAsync(
-        {
+                uploadIntentConfiguration, request.PictureIntentId.Value, request.UserId, cancellationToken);
-            await eventBus.PublishAsync(
+
-                new CreatePlayListResourcesEvent(
+            if (validation.IsError)
-                    playList.Id, picture.Intent.Id, picture.Intent.Bucket, picture.Intent.Key, picture.FinalKey, picture.Sizes),
+                return validation.Errors;
-                cancellationToken);
+
+            return new ResolvedPlayListPictures(new PlayListPictures
+            {
+                OriginalName = validation.Value.ObjectName,
+                SmallName = validation.Value.ObjectName,
+                MediumName = validation.Value.ObjectName,
+                LargeName = validation.Value.ObjectName
+            }, validation.Value);
         }
 
-        await database.SaveChangesAsync(cancellationToken);
+        private async Task<ErrorOr<Success>> PublishCreatePlayListEventAsync(
-
+            Guid playListId,
-        logger.LogInformation("Created playlist {PlayListId} for user {UserId}", playList.Id, request.UserId);
+            UploadIntent pictureIntent,
-
+            string finalPictureKey,
-        return PlayListApplicationResponse.FromEntity(playList);
+            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

@@ -1,36 +1,62 @@
 using ErrorOr;
 using Mediator;
+using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.Logging;
 using Musify.Application.Contracts;
 using Musify.Application.Events;
-using Musify.Application.Shared;
 using Musify.Domain.ValueObjects;
 
-namespace Musify.Application.PlayLists;
+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 async ValueTask<ErrorOr<Success>> Handle(DeletePlayListCommand request, CancellationToken cancellationToken)
+    public record DeletePlayListCommand(long UserId, Guid PlayListId)
+        : ICommand<ErrorOr<Success>>;
+
+    public class DeletePlayListCommandHandler(
+        IDatabase database,
+        IEventBus eventBus,
+        ILogger<DeletePlayListCommandHandler> logger)
+        : ICommandHandler<DeletePlayListCommand, ErrorOr<Success>>
     {
-        var found = await database.PlayLists.FindOwnedAsync(request.PlayListId, request.UserId, cancellationToken);
+        public async ValueTask<ErrorOr<Success>> Handle(DeletePlayListCommand request, CancellationToken cancellationToken)
-        if (found.IsError)
+        {
-            return found.Errors;
+            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();
+            }
 
-        var playList = found.Value;
+            if (playList.UserId != request.UserId)
-        playList.LifeCycleStatus = LifeCycleStatus.Removing;
+            {
+                logger.LogWarning("Playlist {PlayListId} does not belong to user {UserId}", request.PlayListId, request.UserId);
+                return Error.Unauthorized();
+            }
 
-        await eventBus.PublishAsync(new DeletePlayListEvent(playList.Id, request.UserId), cancellationToken);
+            playList.LifeCycleStatus = LifeCycleStatus.Removing;
-        await database.SaveChangesAsync(cancellationToken);
 
-        logger.LogInformation("Marked playlist {PlayListId} as removing", request.PlayListId);
+            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}");
+            }
 
-        return Result.Success;
+            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,30 +1,42 @@
 using ErrorOr;
-using Mediator;
 using Microsoft.EntityFrameworkCore;
-using Musify.Application.Contracts;
 using Musify.Application.PlayLists.Responses;
-using Musify.Application.Shared;
+using Mediator;
+using Musify.Application.Contracts;
+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 async ValueTask<ErrorOr<PlayListApplicationResponse>> Handle(GetPlayListByIdQuery request, CancellationToken cancellationToken)
+    public record GetPlayListByIdQuery(Guid Id, long? RequestingUserId = null)
-    {
+        : IQuery<ErrorOr<PlayListApplicationResponse>>;
-        var playList = await database.PlayLists
-            .AsNoTracking()
-            .Active()
-            .VisibleTo(request.RequestingUserId)
-            .Where(p => p.Id == request.Id)
-            .SelectResponse()
-            .SingleOrDefaultAsync(cancellationToken);
 
-        return playList == null
+    public class GetPlayListByIdQueryHandler(IDatabase database)
-            ? AppErrors.NotFound("PlayList", request.Id)
+        : IQueryHandler<GetPlayListByIdQuery, ErrorOr<PlayListApplicationResponse>>
-            : playList;
+    {
+        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)
+                return Error.NotFound();
+
+            return PlayListApplicationResponse.FromEntity(entry.PlayList, entry.CoverTrackIds);
+        }
     }
 }

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

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

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

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

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

@@ -0,0 +1,43 @@
+using ErrorOr;
+using Microsoft.EntityFrameworkCore;
+using Musify.Application.Shared;
+using Musify.Application.PlayLists.Responses;
+using X.PagedList;
+using X.PagedList.EF;
+using Mediator;
+using Musify.Application.Contracts;
+
+namespace Musify.Application.PlayLists
+{
+    public record GetPlayListsQuery(int PageNumber, int PageSize)
+        : IQuery<ErrorOr<PaginatedResponse<PlayListApplicationResponse>>>;
+
+    public class GetPlayListsQueryHandler(IDatabase database)
+        : IQueryHandler<GetPlayListsQuery, ErrorOr<PaginatedResponse<PlayListApplicationResponse>>>
+    {
+        public async ValueTask<ErrorOr<PaginatedResponse<PlayListApplicationResponse>>> Handle(GetPlayListsQuery request, CancellationToken cancellationToken)
+        {
+            var totalCount = await database.PlayLists.CountAsync(cancellationToken);
+
+            var pagedEntities = await database.PlayLists
+                .AsNoTracking()
+                .OrderBy(p => p.Id)
+                .Select(p => new
+                {
+                    PlayList = p,
+                    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/GetPlayListsByUserId.cs

@@ -1,40 +1,64 @@
+using ErrorOr;
 using Mediator;
 using Microsoft.EntityFrameworkCore;
 using Musify.Application.Contracts;
 using Musify.Application.PlayLists.Responses;
 using Musify.Application.Shared;
+using Musify.Domain.ValueObjects;
+using X.PagedList;
+using X.PagedList.EF;
 
-namespace Musify.Application.PlayLists;
+namespace Musify.Application.PlayLists
-
-public record GetPlayListsByUserIdQuery(
-    long UserId,
-    string? Name,
-    int PageNumber,
-    int PageSize,
-    long? ViewerId = null)
-    : IQuery<PaginatedResponse<PlayListApplicationResponse>>;
-
-public class GetPlayListsByUserIdQueryHandler(IDatabase database)
-    : IQueryHandler<GetPlayListsByUserIdQuery, PaginatedResponse<PlayListApplicationResponse>>
 {
-    public async ValueTask<PaginatedResponse<PlayListApplicationResponse>> Handle(GetPlayListsByUserIdQuery request, CancellationToken cancellationToken)
+    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>>>
     {
-        var playListsQuery = database.PlayLists
+        public async ValueTask<ErrorOr<PaginatedResponse<PlayListApplicationResponse>>> Handle(GetPlayListsByUserIdQuery request, CancellationToken cancellationToken)
-            .AsNoTracking()
-            .Active()
-            .VisibleTo(request.ViewerId)
-            .Where(playList => playList.OwnerUserId == request.UserId);
-
-        if (!string.IsNullOrWhiteSpace(request.Name))
         {
-            var normalizedName = TextNormalizer.Normalize(request.Name);
+            var playListsQuery = database.PlayLists
-            playListsQuery = playListsQuery.Where(playList => playList.NormalizedName.Contains(normalizedName));
+                .AsNoTracking()
-        }
+                .Where(p => p.UserId == request.UserId);
 
-        return await playListsQuery
+            if (request.OnlyPublic)
-            .OrderBy(playList => playList.CreatedAt)
+            {
-            .ThenBy(playList => playList.Id)
+                playListsQuery = playListsQuery.Where(p => p.Visibility == PlaylistVisibility.Public);
-            .SelectResponse()
+            }
-            .ToPaginatedAsync(new PageRequest(request.PageNumber, request.PageSize), cancellationToken);
+
+            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

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

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

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

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

@@ -1,45 +1,37 @@
 using Musify.Domain.Entities;
 using Musify.Domain.ValueObjects;
 
-
+namespace Musify.Application.PlayLists.Responses
-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,
-    long OwnerUserId,
-    int TrackCount,
-    double DurationSeconds)
 {
-    public const int CoverTrackCount = PlayListProjections.CoverTrackCount;
+    public record PlayListApplicationResponse(
-
+        Guid Id,
-    public static PlayListApplicationResponse FromEntity(
+        string Name,
-        PlayList playList,
+        string? Description,
-        IReadOnlyList<Guid>? coverTrackIds = null,
+        string? SmallImageKeyName,
-        int trackCount = 0,
+        string? MediumImageKeyName,
-        double durationSeconds = 0)
+        string? LargeImageKeyName,
+        PlaylistVisibility Visibility,
+        DateTime CreatedAt,
+        DateTime UpdatedAt,
+        IReadOnlyList<Guid> CoverTrackIds)
     {
-        return new PlayListApplicationResponse(
+        public const int CoverTrackCount = 4;
-            playList.Id,
+
-            playList.Name,
+        public static PlayListApplicationResponse FromEntity(
-            playList.Description,
+            PlayList playList,
-            playList.Pictures?.SmallName,
+            IReadOnlyList<Guid>? coverTrackIds = null)
-            playList.Pictures?.MediumName,
+        {
-            playList.Pictures?.LargeName,
+            return new PlayListApplicationResponse(
-            playList.Visibility,
+                playList.Id,
-            playList.CreatedAt,
+                playList.Name,
-            playList.UpdatedAt,
+                playList.Description,
-            coverTrackIds ?? [],
+                playList.Pictures?.SmallName,
-            playList.OwnerUserId,
+                playList.Pictures?.MediumName,
-            trackCount,
+                playList.Pictures?.LargeName,
-            durationSeconds);
+                playList.Visibility,
+                playList.CreatedAt,
+                playList.UpdatedAt,
+                coverTrackIds ?? []);
+        }
     }
 }

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

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

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

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

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

@@ -3,78 +3,153 @@ using Mediator;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.Logging;
 using Musify.Application.Configuration;
-using Musify.Application.Contracts;
+using Musify.Application.Shared;
 using Musify.Application.Events;
-using Musify.Application.Pictures;
 using Musify.Application.PlayLists.Responses;
 using Musify.Application.Services;
-using Musify.Application.Shared;
+using Musify.Domain.Entities;
 using Musify.Domain.ValueObjects;
+using Musify.Application.Contracts;
 
-namespace Musify.Application.PlayLists;
+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,
-    PlayListConfiguration playListConfiguration)
-    : ICommandHandler<UpdatePlayListCommand, ErrorOr<PlayListApplicationResponse>>
 {
-    public async ValueTask<ErrorOr<PlayListApplicationResponse>> Handle(UpdatePlayListCommand request, CancellationToken cancellationToken)
+    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>>
     {
-        var found = await database.PlayLists.FindOwnedAsync(request.PlayListId, request.UserId, cancellationToken);
+        public async ValueTask<ErrorOr<PlayListApplicationResponse>> Handle(UpdatePlayListCommand request, CancellationToken cancellationToken)
-        if (found.IsError)
-            return found.Errors;
-
-        var playList = found.Value;
-
-        if (!string.IsNullOrWhiteSpace(request.NewName))
         {
-            playList.Name = request.NewName.Trim();
+            var playListEntity = await database.PlayLists.SingleOrDefaultAsync(pl => pl.Id == request.PlayListId, cancellationToken);
-            playList.NormalizedName = TextNormalizer.Normalize(request.NewName);
+            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);
         }
 
-        // null means "unchanged"; a blank description clears it.
+        private async Task<ErrorOr<Success>> PublishUpdatePlayListPictureSourceEventAsync(
-        if (request.NewDescription != null)
+            Guid playListId,
-            playList.Description = string.IsNullOrWhiteSpace(request.NewDescription) ? null : request.NewDescription.Trim();
+            UploadIntent pictureIntent,
-
+            string finalPictureKey,
-        if (request.NewVisibility is { } visibility)
+            CancellationToken cancellationToken)
-            playList.Visibility = visibility;
-
-        if (request.NewPictureIntentId is { } intentId)
         {
-            var prepared = await PictureSourceChange.PrepareAsync(
+            try
-                uploadIntentValidator, intentId, request.UserId, UploadIntentPurpose.PlayListPicture, playListConfiguration, cancellationToken);
+            {
-            if (prepared.IsError)
+                await eventBus.PublishAsync(
-                return prepared.Errors;
+                    new UpdatePlayListPictureSourceEvent(
-
+                        playListId,
-            var picture = prepared.Value;
+                        pictureIntent.Id,
-            playList.Pictures = picture.Pictures;
+                        storageConfiguration.Bucket,
-
+                        pictureIntent.Key,
-            await eventBus.PublishAsync(
+                        finalPictureKey,
-                new UpdatePlayListPictureSourceEvent(
+                        new ImageSize(
-                    playList.Id, picture.Intent.Id, picture.Intent.Bucket, picture.Intent.Key, picture.FinalKey, picture.Sizes),
+                            playListConfiguration.Routes.SmallPicturesPath,
-                cancellationToken);
+                            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}");
+            }
         }
-
-        await database.SaveChangesAsync(cancellationToken);
-
-        logger.LogInformation("Updated playlist {PlayListId}", playList.Id);
-
-        return await database.PlayLists
-            .AsNoTracking()
-            .Where(p => p.Id == playList.Id)
-            .SelectResponse()
-            .SingleAsync(cancellationToken);
     }
 }

backend/Core/Musify.Application/Serialization/LongAsStringConverter.cs

@@ -2,7 +2,7 @@ using System.Globalization;
 using System.Text.Json;
 using System.Text.Json.Serialization;
 
-namespace Musify.Api.Serialization;
+namespace Musify.Application.Serialization;
 
 public sealed class LongAsStringConverter : JsonConverter<long>
 {

backend/Core/Musify.Application/Services/TrackStreamIssuer.cs

@@ -1,20 +1,28 @@
 using Musify.Application.Configuration;
 using Musify.Application.Contracts;
 using Musify.Application.Tracks.Responses;
+using Musify.Domain.Entities;
 
 namespace Musify.Application.Services;
 
-/// <summary>Builds the stream URL and signed ticket for a processed track. It never touches the database.</summary>
 public sealed class TrackStreamIssuer(
+    IDatabase database,
     IStreamTicketService ticketService,
     TrackConfiguration trackConfiguration,
     StreamGatewayConfiguration streamGatewayConfiguration,
     PlaybackConfiguration playbackConfiguration)
 {
-    public TrackStreamResponse Issue(string audioFolderName, long? userId, Guid? listenId)
+    public async Task<TrackStreamResponse> IssueAsync(
+        Guid trackId,
+        string audioFolderName,
+        long? userId,
+        CancellationToken cancellationToken)
     {
         var folderPath = trackConfiguration.Routes.BuildProcessedAudioPath(audioFolderName);
-        var ticket = ticketService.IssueTicket(userId, $"{folderPath}/", AnonymousFragmentBytes(userId));
+        var keyPrefix = $"{folderPath}/";
+
+        var maxBytes = AnonymousFragmentBytes(userId);
+        var ticket = ticketService.IssueTicket(userId, keyPrefix, maxBytes);
 
         var manifestUrl = string.Join('/',
             streamGatewayConfiguration.PublicBaseUrl.TrimEnd('/'),
@@ -22,6 +30,19 @@ public sealed class TrackStreamIssuer(
             folderPath,
             streamGatewayConfiguration.AudioFileName);
 
+        Guid? listenId = null;
+        if (userId != null)
+        {
+            var newListeningHistory = new ListeningHistory
+            {
+                UserId = userId.Value,
+                TrackId = trackId,
+            };
+            await database.ListeningHistories.AddAsync(newListeningHistory, cancellationToken);
+            await database.SaveChangesAsync(cancellationToken);
+            listenId = newListeningHistory.Id;
+        }
+
         return new TrackStreamResponse(manifestUrl, ticket.Token, ticket.ExpiresInSeconds, listenId);
     }