Separate responsibilities: start-listening command, API-side JSON converters, bulk track endpoints, mix kinds

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

@@ -1,58 +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;
-
-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.FindOwnedAsync(request.AlbumId, request.UserId, cancellationToken);
-        if (album.IsError)
-            return album.Errors;
-
-        var track = await database.Tracks.FindOwnedAsync(request.TrackId, request.UserId, cancellationToken);
-        if (track.IsError)
-            return track.Errors;
-
-        var alreadyAdded = await database.AlbumHasTracks
-            .AsNoTracking()
-            .AnyAsync(albumTrack => albumTrack.AlbumId == request.AlbumId && albumTrack.TrackId == request.TrackId, cancellationToken);
-        if (alreadyAdded)
-            return AlreadyInAlbum;
-
-        // Album track numbers are user-visible, so they start at 1.
-        var nextTrackNumber = (await database.AlbumHasTracks
-            .Where(albumTrack => albumTrack.AlbumId == request.AlbumId)
-            .MaxAsync(albumTrack => (int?)albumTrack.TrackNumber, cancellationToken) ?? 0) + 1;
-
-        await database.AlbumHasTracks.AddAsync(new AlbumHasTrack
-        {
-            AlbumId = request.AlbumId,
-            TrackId = request.TrackId,
-            TrackNumber = nextTrackNumber
-        }, cancellationToken);
-
-        var saved = await database.TrySaveChangesAsync(AlreadyInAlbum, cancellationToken);
-        if (saved.IsError)
-            return saved;
-
-        logger.LogInformation("Added track {TrackId} to album {AlbumId} as number {TrackNumber}",
-            request.TrackId, request.AlbumId, nextTrackNumber);
-
-        return Result.Success;
-    }
-
-    private static Error AlreadyInAlbum => AppErrors.Conflict("Album.TrackAlreadyAdded", "Track is already in the album.");
-}

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

@@ -0,0 +1,77 @@
+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/Responses/AlbumApplicationResponse.cs

@@ -1,5 +1,3 @@
-using System.Text.Json.Serialization;
-using Musify.Application.Serialization;
 using Musify.Domain.Entities;
 
 namespace Musify.Application.Albums.Responses;
@@ -9,7 +7,7 @@ public record AlbumApplicationResponse(
     string Title,
     string? Description,
     int? ReleaseYear,
-    [property: JsonConverter(typeof(LongAsStringConverter))] long OwnerUserId,
+    long OwnerUserId,
     int TrackCount,
     string? SmallImageKeyName,
     string? MediumImageKeyName,

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

@@ -16,8 +16,6 @@ public interface IDatabase
 
     public DbSet<Track> Tracks { get; }
 
-    public DbSet<UserHasTrack> UserHasTracks { get; }
-
     public DbSet<PlayListHasTrack> PlayListHasTracks { get; }
 
     public DbSet<Mix> Mixes { get; }

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

@@ -15,7 +15,7 @@ public class GetGenresQueryHandler(IDatabase database)
     {
         var rows = await database.TrackTags
             .AsNoTracking()
-            .Where(tag => database.UserHasTracks.Any(userTrack => userTrack.TrackId == tag.TrackId && userTrack.Track.LifeCycleStatus == LifeCycleStatus.Active))
+            .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);

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

@@ -18,16 +18,16 @@ public class GenerateMixesForUserCommandHandler(
     ILogger<GenerateMixesForUserCommandHandler> logger)
     : ICommandHandler<GenerateMixesForUserCommand, ErrorOr<Success>>
 {
-    private sealed record MixDraft(string Title, string? Subtitle, IReadOnlyList<Guid> TrackIds);
+    private sealed record MixDraft(MixKind Kind, IReadOnlyList<Guid> TrackIds);
 
     public async ValueTask<ErrorOr<Success>> Handle(GenerateMixesForUserCommand request, CancellationToken cancellationToken)
     {
         var userId = request.UserId;
 
-        var libraryTrackIds = await database.UserHasTracks
+        var libraryTrackIds = await database.Tracks
             .AsNoTracking()
-            .Where(userTrack => userTrack.UserId == userId && userTrack.Track.LifeCycleStatus == LifeCycleStatus.Active)
+            .Where(track => track.OwnerUserId == userId && track.LifeCycleStatus == LifeCycleStatus.Active)
-            .Select(userTrack => userTrack.TrackId)
+            .Select(track => track.Id)
             .ToListAsync(cancellationToken);
 
         if (libraryTrackIds.Count == 0)
@@ -51,19 +51,13 @@ public class GenerateMixesForUserCommandHandler(
         var discovery = Take(Shuffle(unheardTrackIds));
         if (discovery.Count > 0)
         {
-            drafts.Add(new MixDraft(
+            drafts.Add(new MixDraft(MixKind.Discovery, discovery));
-                "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(
+            drafts.Add(new MixDraft(MixKind.Daily, daily));
-                "Tu mezcla diaria",
-                "Lo que más escuchas, con alguna sorpresa de tu biblioteca.",
-                daily));
         }
 
         if (drafts.Count == 0)
@@ -108,12 +102,6 @@ public class GenerateMixesForUserCommandHandler(
 
         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);
         }
 
@@ -123,8 +111,7 @@ public class GenerateMixesForUserCommandHandler(
             var mix = new Mix
             {
                 UserId = userId,
-                Title = draft.Title,
+                Kind = draft.Kind,
-                Subtitle = draft.Subtitle,
                 Position = position
             };
 

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

@@ -26,6 +26,6 @@ public class GetMixByIdQueryHandler(IDatabase database)
         var orderedItems = mix.Items.OrderBy(item => item.Position).ToList();
         var items = await MixItemMapper.ToResponsesAsync(database, orderedItems, cancellationToken);
 
-        return new MixApplicationResponse(mix.Id, mix.Title, mix.Subtitle, items.Count, items);
+        return new MixApplicationResponse(mix.Id, mix.Kind, items.Count, items);
     }
 }

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

@@ -42,7 +42,7 @@ public class GetMixesByUserIdQueryHandler(IDatabase database)
                 .Select(item => coverResponses[item.TrackId])
                 .ToList();
 
-            responses.Add(new MixApplicationResponse(mix.Id, mix.Title, mix.Subtitle, orderedItems.Count, covers));
+            responses.Add(new MixApplicationResponse(mix.Id, mix.Kind, orderedItems.Count, covers));
         }
 
         return responses;

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

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

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

@@ -1,61 +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;
-
-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.FindOwnedAsync(request.PlayListId, request.UserId, cancellationToken);
-        if (playList.IsError)
-            return playList.Errors;
-
-        var trackExists = await database.Tracks
-            .AsNoTracking()
-            .AnyAsync(t => t.Id == request.TrackId && t.LifeCycleStatus == LifeCycleStatus.Active, cancellationToken);
-        if (!trackExists)
-            return AppErrors.NotFound("Track", request.TrackId);
-
-        var alreadyAdded = await database.PlayListHasTracks
-            .AsNoTracking()
-            .AnyAsync(plt => plt.PlayListId == request.PlayListId && plt.TrackId == request.TrackId, cancellationToken);
-        if (alreadyAdded)
-            return AlreadyInPlayList;
-
-        // Playlist positions are internal indexes, so they start at 0.
-        var nextPosition = (await database.PlayListHasTracks
-            .Where(plt => plt.PlayListId == request.PlayListId)
-            .MaxAsync(plt => (int?)plt.Position, cancellationToken) ?? -1) + 1;
-
-        await database.PlayListHasTracks.AddAsync(new PlayListHasTrack
-        {
-            PlayListId = request.PlayListId,
-            TrackId = request.TrackId,
-            Position = nextPosition
-        }, cancellationToken);
-
-        var saved = await database.TrySaveChangesAsync(AlreadyInPlayList, cancellationToken);
-        if (saved.IsError)
-            return saved;
-
-        logger.LogInformation("Added track {TrackId} to playlist {PlayListId} at position {Position}",
-            request.TrackId, request.PlayListId, nextPosition);
-
-        return Result.Success;
-    }
-
-    private static Error AlreadyInPlayList => AppErrors.Conflict("PlayList.TrackAlreadyAdded", "Track is already in the playlist.");
-}

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

@@ -0,0 +1,73 @@
+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/Responses/PlayListApplicationResponse.cs

@@ -1,8 +1,6 @@
 using Musify.Domain.Entities;
 using Musify.Domain.ValueObjects;
 
-using System.Text.Json.Serialization;
-using Musify.Application.Serialization;
 
 namespace Musify.Application.PlayLists.Responses;
 
@@ -17,7 +15,7 @@ public record PlayListApplicationResponse(
     DateTime CreatedAt,
     DateTime UpdatedAt,
     IReadOnlyList<Guid> CoverTrackIds,
-    [property: JsonConverter(typeof(LongAsStringConverter))] long OwnerUserId,
+    long OwnerUserId,
     int TrackCount,
     double DurationSeconds)
 {

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

@@ -1,28 +1,20 @@
 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 async Task<TrackStreamResponse> IssueAsync(
+    public TrackStreamResponse Issue(string audioFolderName, long? userId, Guid? listenId)
-        Guid trackId,
-        string audioFolderName,
-        long? userId,
-        CancellationToken cancellationToken)
     {
         var folderPath = trackConfiguration.Routes.BuildProcessedAudioPath(audioFolderName);
-        var keyPrefix = $"{folderPath}/";
+        var ticket = ticketService.IssueTicket(userId, $"{folderPath}/", AnonymousFragmentBytes(userId));
-
-        var maxBytes = AnonymousFragmentBytes(userId);
-        var ticket = ticketService.IssueTicket(userId, keyPrefix, maxBytes);
 
         var manifestUrl = string.Join('/',
             streamGatewayConfiguration.PublicBaseUrl.TrimEnd('/'),
@@ -30,19 +22,6 @@ 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);
     }
 

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

@@ -41,21 +41,6 @@ public class CreateTrackCommandHandler(
         }
 
         var distinctTags = request.Tags.Distinct().ToList();
-        if (distinctTags.Count == 0)
-        {
-            logger.LogWarning("Track {Title} was submitted without any tags", request.Title);
-            return Error.Validation(description: "At least one tag is required.");
-        }
-
-        var tagConflicts = GenreCompatibility.FindConflicts(distinctTags);
-        if (tagConflicts.Count > 0)
-        {
-            var conflict = tagConflicts.First();
-            logger.LogWarning(
-                "Track {Title} was submitted with incompatible tags {First} and {Second}",
-                request.Title, conflict.First, conflict.Second);
-            return Error.Validation(description: $"Tags '{conflict.First}' and '{conflict.Second}' are not compatible.");
-        }
 
         if (request.PictureIntentId == request.AudioIntentId)
             return Error.Validation(description: "Picture and audio must use different upload intents.");
@@ -105,11 +90,6 @@ public class CreateTrackCommandHandler(
 
         await database.Tracks.AddAsync(trackEntity, cancellationToken);
 
-        await database.UserHasTracks.AddAsync(new UserHasTrack
-        {
-            UserId = request.UserId,
-            TrackId = trackEntity.Id
-        }, cancellationToken);
 
         var sizes = trackConfiguration.PicturesSizes.ToImageSizes(trackConfiguration.Routes);
         await eventBus.PublishAsync(

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

@@ -17,9 +17,6 @@ public class RecordListeningProgressCommandHandler(IDatabase database)
 {
     public async ValueTask<ErrorOr<Success>> Handle(RecordListeningProgressCommand request, CancellationToken cancellationToken)
     {
-        if (!double.IsFinite(request.PlayedSeconds) || request.PlayedSeconds < 0)
-            return Error.Validation(description: "playedSeconds must be a non-negative number.");
-
         var listen = await database.ListeningHistories
             .Include(l => l.Track)
             .SingleOrDefaultAsync(l => l.Id == request.ListenId && l.UserId == request.UserId, cancellationToken);

backend/Core/Musify.Application/Tracks/Responses/TrackApplicationResponse.cs

@@ -1,5 +1,3 @@
-using System.Text.Json.Serialization;
-using Musify.Application.Serialization;
 using Musify.Domain.Entities;
 using Musify.Domain.ValueObjects;
 
@@ -14,7 +12,7 @@ public record TrackApplicationResponse(
     int ListensCount,
     DateTime CreatedAt,
     DateTime UpdatedAt,
-    [property: JsonConverter(typeof(LongAsStringConverter))] long OwnerUserId,
+    long OwnerUserId,
     IReadOnlyCollection<Genre> Tags,
     bool IsExplicit)
 {

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

@@ -5,24 +5,25 @@ using Microsoft.Extensions.Logging;
 using Musify.Application.Configuration;
 using Musify.Application.Contracts;
 using Musify.Application.Services;
-using Musify.Application.Tracks.Responses;
-using Musify.Domain.ValueObjects;
 using Musify.Application.Shared;
+using Musify.Application.Tracks.Responses;
+using Musify.Domain.Entities;
+using Musify.Domain.ValueObjects;
 
 namespace Musify.Application.Tracks;
 
+/// <summary>Starts a listen: records it for signed-in users and issues the stream ticket.</summary>
+public record StartListeningCommand(Guid TrackId, long? UserId)
+    : ICommand<ErrorOr<TrackStreamResponse>>;
 
-public record GetTrackStreamQuery(Guid TrackId, long? UserId)
+public class StartListeningCommandHandler(
-    : IQuery<ErrorOr<TrackStreamResponse>>;
-
-public class GetTrackStreamQueryHandler(
     IDatabase database,
     TrackStreamIssuer streamIssuer,
     PlaybackConfiguration playbackConfiguration,
-    ILogger<GetTrackStreamQueryHandler> logger)
+    ILogger<StartListeningCommandHandler> logger)
-    : IQueryHandler<GetTrackStreamQuery, ErrorOr<TrackStreamResponse>>
+    : ICommandHandler<StartListeningCommand, ErrorOr<TrackStreamResponse>>
 {
-    public async ValueTask<ErrorOr<TrackStreamResponse>> Handle(GetTrackStreamQuery request, CancellationToken cancellationToken)
+    public async ValueTask<ErrorOr<TrackStreamResponse>> Handle(StartListeningCommand request, CancellationToken cancellationToken)
     {
         if (request.UserId == null && !playbackConfiguration.AllowAnonymousListening)
             return Error.Unauthorized(description: "Sign in to stream music, or ask an administrator to enable anonymous listening.");
@@ -38,10 +39,17 @@ public class GetTrackStreamQueryHandler(
         if (!track.Audio.IsProcessed)
             return AppErrors.Conflict("Track.AudioNotReady", "Track audio is not available for streaming yet.");
 
-        var response = await streamIssuer.IssueAsync(track.Id, track.Audio.FolderName, request.UserId, cancellationToken);
+        Guid? listenId = null;
+        if (request.UserId is { } userId)
+        {
+            var listen = new ListeningHistory { UserId = userId, TrackId = track.Id };
+            await database.ListeningHistories.AddAsync(listen, cancellationToken);
+            await database.SaveChangesAsync(cancellationToken);
+            listenId = listen.Id;
+        }
 
         logger.LogInformation("Issued stream ticket for track {TrackId} to user {UserId}", request.TrackId, request.UserId?.ToString() ?? "(anonymous)");
 
-        return response;
+        return streamIssuer.Issue(track.Audio.FolderName, request.UserId, listenId);
     }
 }

backend/Core/Musify.Application/Users/Responses/UserApplicationResponse.cs

@@ -1,11 +1,9 @@
-using System.Text.Json.Serialization;
-using Musify.Application.Serialization;
 using Musify.Domain.Entities;
 
 namespace Musify.Application.Users.Responses;
 
 public record UserApplicationResponse(
-    [property: JsonConverter(typeof(LongAsStringConverter))] long Id,
+    long Id,
     string Name,
     string? FirstName,
     string? SecondName,

backend/Core/Musify.Application/Users/Responses/UserProfileResponse.cs

@@ -1,10 +1,8 @@
-using System.Text.Json.Serialization;
-using Musify.Application.Serialization;
 
 namespace Musify.Application.Users.Responses;
 
 public record UserProfileResponse(
-    [property: JsonConverter(typeof(LongAsStringConverter))] long Id,
+    long Id,
     string Name,
     string? FirstName,
     string? SecondName,

backend/Core/Musify.Application/Users/Responses/UserSummaryResponse.cs

@@ -1,10 +1,8 @@
-using System.Text.Json.Serialization;
-using Musify.Application.Serialization;
 
 namespace Musify.Application.Users.Responses;
 
 public record UserSummaryResponse(
-    [property: JsonConverter(typeof(LongAsStringConverter))] long Id,
+    long Id,
     string Name,
     string? FirstName,
     string? SecondName,

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

@@ -1,4 +1,5 @@
 using System.ComponentModel.DataAnnotations;
+using Musify.Domain.ValueObjects;
 using System.ComponentModel.DataAnnotations.Schema;
 
 using Musify.Domain.Abstractions;
@@ -13,11 +14,7 @@ public class Mix : IAuditable
 
     public required long UserId { get; set; }
 
-    [MaxLength(100)]
+    public MixKind Kind { get; set; }
-    public required string Title { get; set; }
-
-    [MaxLength(256)]
-    public string? Subtitle { get; set; }
 
     public int Position { get; set; }
 

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

@@ -36,8 +36,6 @@ public class Track : IAuditable, IHasLifeCycle, IOwnedEntity
 
     public TrackAudio Audio { get; set; } = new();
 
-    public ICollection<UserHasTrack> UserTracks { get; set; } = new List<UserHasTrack>();
-
     public ICollection<PlayListHasTrack> PlayListTracks { get; set; } = new List<PlayListHasTrack>();
 
     public ICollection<AlbumHasTrack> AlbumTracks { get; set; } = new List<AlbumHasTrack>();

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

@@ -30,8 +30,6 @@ public class User : IAuditable
 
     public DateTime UpdatedAt { get; set; } = DateTime.UtcNow;
 
-    public ICollection<UserHasTrack> UserTracks { get; set; } = new List<UserHasTrack>();
-
     public ICollection<PlayList> PlayLists { get; set; } = new List<PlayList>();
 
     public ICollection<ListeningHistory> ListeningHistories { get; set; } = new List<ListeningHistory>();

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

@@ -1,19 +0,0 @@
-using System.ComponentModel.DataAnnotations.Schema;
-
-namespace Musify.Domain.Entities;
-
-[Table("UserHasTrack")]
-public class UserHasTrack
-{
-    public Guid Id { get; set; } = Guid.NewGuid();
-
-    public required long UserId { get; set; }
-
-    public required Guid TrackId { get; set; }
-
-    [ForeignKey(nameof(UserId))]
-    public User User { get; set; } = null!;
-
-    [ForeignKey(nameof(TrackId))]
-    public Track Track { get; set; } = null!;
-}

backend/Core/Musify.Domain/ValueObjects/MixKind.cs

@@ -0,0 +1,7 @@
+namespace Musify.Domain.ValueObjects;
+
+public enum MixKind
+{
+    Discovery = 0,
+    Daily = 1
+}

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

@@ -181,8 +181,6 @@ public class Database(DatabaseConfiguration configuration)
 
     public DbSet<AlbumHasTrack> AlbumHasTracks => Set<AlbumHasTrack>();
 
-    public DbSet<UserHasTrack> UserHasTracks => Set<UserHasTrack>();
-
     public DbSet<PlayListHasTrack> PlayListHasTracks => Set<PlayListHasTrack>();
 
     public DbSet<Mix> Mixes => Set<Mix>();

backend/Core/Musify.Infrastructure/Persistence/Migrations/20260924101123_DropUserHasTrack.cs

@@ -0,0 +1,57 @@
+using System;
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace Musify.Infrastructure.Persistence.Migrations
+{
+    /// <inheritdoc />
+    public partial class DropUserHasTrack : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropTable(
+                name: "UserHasTrack");
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.CreateTable(
+                name: "UserHasTrack",
+                columns: table => new
+                {
+                    Id = table.Column<Guid>(type: "uuid", nullable: false),
+                    TrackId = table.Column<Guid>(type: "uuid", nullable: false),
+                    UserId = table.Column<long>(type: "bigint", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_UserHasTrack", x => x.Id);
+                    table.ForeignKey(
+                        name: "FK_UserHasTrack_Tracks_TrackId",
+                        column: x => x.TrackId,
+                        principalTable: "Tracks",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Cascade);
+                    table.ForeignKey(
+                        name: "FK_UserHasTrack_User_UserId",
+                        column: x => x.UserId,
+                        principalTable: "User",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateIndex(
+                name: "IX_UserHasTrack_TrackId",
+                table: "UserHasTrack",
+                column: "TrackId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_UserHasTrack_UserId",
+                table: "UserHasTrack",
+                column: "UserId");
+        }
+    }
+}

backend/Core/Musify.Infrastructure/Persistence/Migrations/20260924101237_MixKind.cs

@@ -0,0 +1,55 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace Musify.Infrastructure.Persistence.Migrations
+{
+    /// <inheritdoc />
+    public partial class MixKind : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<int>(
+                name: "Kind",
+                table: "Mixes",
+                type: "integer",
+                nullable: false,
+                defaultValue: 0);
+
+            // Mixes used to store their Spanish title; the daily mix is kind 1, everything else is discovery.
+            migrationBuilder.Sql("UPDATE \"Mixes\" SET \"Kind\" = 1 WHERE \"Title\" = 'Tu mezcla diaria';");
+
+            migrationBuilder.DropColumn(
+                name: "Subtitle",
+                table: "Mixes");
+
+            migrationBuilder.DropColumn(
+                name: "Title",
+                table: "Mixes");
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropColumn(
+                name: "Kind",
+                table: "Mixes");
+
+            migrationBuilder.AddColumn<string>(
+                name: "Subtitle",
+                table: "Mixes",
+                type: "character varying(256)",
+                maxLength: 256,
+                nullable: true);
+
+            migrationBuilder.AddColumn<string>(
+                name: "Title",
+                table: "Mixes",
+                type: "character varying(100)",
+                maxLength: 100,
+                nullable: false,
+                defaultValue: "");
+        }
+    }
+}

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

@@ -304,17 +304,11 @@ namespace Musify.Infrastructure.Persistence.Migrations
                     b.Property<DateTime>("CreatedAt")
                         .HasColumnType("timestamp with time zone");
 
-                    b.Property<int>("Position")
+                    b.Property<int>("Kind")
                         .HasColumnType("integer");
 
-                    b.Property<string>("Subtitle")
+                    b.Property<int>("Position")
-                        .HasMaxLength(256)
+                        .HasColumnType("integer");
-                        .HasColumnType("character varying(256)");
-
-                    b.Property<string>("Title")
-                        .IsRequired()
-                        .HasMaxLength(100)
-                        .HasColumnType("character varying(100)");
 
                     b.Property<DateTime>("UpdatedAt")
                         .HasColumnType("timestamp with time zone");
@@ -626,27 +620,6 @@ namespace Musify.Infrastructure.Persistence.Migrations
                     b.ToTable("UserFollows");
                 });
 
-            modelBuilder.Entity("Musify.Domain.Entities.UserHasTrack", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("uuid");
-
-                    b.Property<Guid>("TrackId")
-                        .HasColumnType("uuid");
-
-                    b.Property<long>("UserId")
-                        .HasColumnType("bigint");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("TrackId");
-
-                    b.HasIndex("UserId");
-
-                    b.ToTable("UserHasTrack");
-                });
-
             modelBuilder.Entity("Musify.Infrastructure.MassTransit.Sagas.AlbumProcessingState", b =>
                 {
                     b.Property<Guid>("CorrelationId")
@@ -1070,25 +1043,6 @@ namespace Musify.Infrastructure.Persistence.Migrations
                     b.Navigation("Follower");
                 });
 
-            modelBuilder.Entity("Musify.Domain.Entities.UserHasTrack", b =>
-                {
-                    b.HasOne("Musify.Domain.Entities.Track", "Track")
-                        .WithMany("UserTracks")
-                        .HasForeignKey("TrackId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.HasOne("Musify.Domain.Entities.User", "User")
-                        .WithMany("UserTracks")
-                        .HasForeignKey("UserId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.Navigation("Track");
-
-                    b.Navigation("User");
-                });
-
             modelBuilder.Entity("Musify.Domain.Entities.Album", b =>
                 {
                     b.Navigation("AlbumTracks");
@@ -1113,8 +1067,6 @@ namespace Musify.Infrastructure.Persistence.Migrations
                     b.Navigation("PlayListTracks");
 
                     b.Navigation("Tags");
-
-                    b.Navigation("UserTracks");
                 });
 
             modelBuilder.Entity("Musify.Domain.Entities.User", b =>
@@ -1122,8 +1074,6 @@ namespace Musify.Infrastructure.Persistence.Migrations
                     b.Navigation("ListeningHistories");
 
                     b.Navigation("PlayLists");
-
-                    b.Navigation("UserTracks");
                 });
 #pragma warning restore 612, 618
         }

backend/Hosts/Musify.Api/DataTransferObjects/AddTracksRequest.cs

@@ -0,0 +1,3 @@
+namespace Musify.Api.DataTransferObjects;
+
+public record AddTracksRequest(IReadOnlyList<Guid> TrackIds);

backend/Hosts/Musify.Api/DataTransferObjects/PlayLists/AddPlayListTrackRequest.cs

@@ -1,3 +0,0 @@
-namespace Musify.Api.DataTransferObjects.PlayLists;
-
-public record AddPlayListTrackRequest(Guid TrackId);

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

@@ -1,5 +1,6 @@
 using Mediator;
 using Musify.Api.Authentication;
+using Musify.Api.DataTransferObjects;
 using Musify.Api.DataTransferObjects.Albums;
 using Musify.Api.Extensions;
 using Musify.Api.Filters;
@@ -102,11 +103,13 @@ public static class AlbumEndpoints
             .Produces(StatusCodes.Status403Forbidden)
             .Produces(StatusCodes.Status404NotFound);
 
-        group.MapPost("/{albumId}/tracks/{trackId}", AddTrackToAlbum)
+        group.MapPost("/{id}/tracks", AddAlbumTracks)
-            .WithName("AddTrackToAlbum")
+            .WithName("AddAlbumTracks")
-            .WithSummary("Add One Of Your Uploaded Tracks To An Album.")
+            .WithSummary("Add Your Uploaded Tracks To An Album, Skipping The Ones It Already Has.")
+            .AddEndpointFilter<ValidationFilter<AddTracksRequest>>()
             .RequireAuthorization()
             .Produces(StatusCodes.Status204NoContent)
+            .ProducesValidationProblem()
             .Produces(StatusCodes.Status401Unauthorized)
             .Produces(StatusCodes.Status403Forbidden)
             .Produces(StatusCodes.Status404NotFound)
@@ -242,15 +245,15 @@ public static class AlbumEndpoints
         return result.ToHttpResult();
     }
 
-    private static async Task<IResult> AddTrackToAlbum(
+    private static async Task<IResult> AddAlbumTracks(
         IMediator mediator,
         CurrentUser currentUser,
-        Guid albumId,
+        Guid id,
-        Guid trackId,
+        AddTracksRequest request,
         CancellationToken cancellationToken)
     {
         var result = await mediator.Send(
-            new AddTrackToAlbumCommand(currentUser.RequiredId, albumId, trackId),
+            new AddTracksToAlbumCommand(currentUser.RequiredId, id, request.TrackIds),
             cancellationToken);
 
         return result.ToHttpResult();

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

@@ -1,5 +1,6 @@
 using Mediator;
 using Musify.Api.Authentication;
+using Musify.Api.DataTransferObjects;
 using Musify.Api.DataTransferObjects.PlayLists;
 using Musify.Api.Extensions;
 using Musify.Api.Filters;
@@ -10,7 +11,6 @@ using Musify.Application.PlayLists;
 using Musify.Application.PlayLists.Responses;
 using Musify.Api.Models;
 using Musify.Application.Shared;
-using Musify.Application.Tracks;
 using Musify.Application.Tracks.Responses;
 
 namespace Musify.Api.Endpoints;
@@ -87,11 +87,13 @@ public static class PlayListEndpoints
             .Produces(StatusCodes.Status401Unauthorized)
             .Produces(StatusCodes.Status404NotFound);
 
-        group.MapPost("/{playlistId}/tracks", AddPlayListTrack)
+        group.MapPost("/{id}/tracks", AddPlayListTracks)
-            .WithName("AddPlayListTrack")
+            .WithName("AddPlayListTracks")
-            .WithSummary("Add One Of Your Tracks To A PlayList.")
+            .WithSummary("Add Tracks To A PlayList, Skipping The Ones It Already Has.")
+            .AddEndpointFilter<ValidationFilter<AddTracksRequest>>()
             .RequireAuthorization()
-            .Produces<TrackApplicationResponse>(StatusCodes.Status201Created)
+            .Produces(StatusCodes.Status204NoContent)
+            .ProducesValidationProblem()
             .Produces(StatusCodes.Status401Unauthorized)
             .Produces(StatusCodes.Status403Forbidden)
             .Produces(StatusCodes.Status404NotFound)
@@ -203,21 +205,18 @@ public static class PlayListEndpoints
         return result.ToHttpResult();
     }
 
-    private static async Task<IResult> AddPlayListTrack(
+    private static async Task<IResult> AddPlayListTracks(
         IMediator mediator,
         CurrentUser currentUser,
-        Guid playlistId,
+        Guid id,
-        AddPlayListTrackRequest request,
+        AddTracksRequest request,
         CancellationToken cancellationToken)
     {
-        var addResult = await mediator.Send(
+        var result = await mediator.Send(
-            new AddTrackToPlayListCommand(currentUser.RequiredId, playlistId, request.TrackId),
+            new AddTracksToPlayListCommand(currentUser.RequiredId, id, request.TrackIds),
             cancellationToken);
-        if (addResult.IsError)
-            return addResult.ToHttpResult();
 
-        var trackResult = await mediator.Send(new GetTrackByIdQuery(request.TrackId), cancellationToken);
+        return result.ToHttpResult();
-        return trackResult.ToCreatedResult(track => $"/tracks/{track.Id}");
     }
 
     private static async Task<IResult> RemoveTrackFromPlayList(

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

@@ -9,7 +9,6 @@ using Musify.Api.Models;
 using Musify.Application.Shared;
 using Musify.Application.Tracks;
 using Musify.Application.Tracks.Responses;
-using Musify.Domain.ValueObjects;
 
 namespace Musify.Api.Endpoints;
 
@@ -47,6 +46,7 @@ public static class TrackEndpoints
             .Produces(StatusCodes.Status404NotFound);
 
         group.MapPut("/listens/{listenId}/progress", RecordListeningProgress)
+            .AddEndpointFilter<ValidationFilter<RecordListeningProgressRequest>>()
             .WithName("RecordListeningProgress")
             .WithSummary("Report The Total Seconds Actually Played For A Listen Started By The Stream Endpoint.")
             .RequireAuthorization()
@@ -99,24 +99,10 @@ public static class TrackEndpoints
         IMediator mediator,
         CancellationToken cancellationToken,
         string? name,
-        string? genre,
+        GenreParameter? genre,
         [AsParameters] PageQuery page)
     {
-        Genre? parsedGenre = null;
+        var result = await mediator.Send(new GetTracksQuery(name, page.PageNumber, page.PageSize, genre?.Value), cancellationToken);
-        if (!string.IsNullOrWhiteSpace(genre))
-        {
-            if (!Enum.TryParse<Genre>(genre, ignoreCase: true, out var value) || !Enum.IsDefined(value))
-            {
-                return Results.ValidationProblem(new Dictionary<string, string[]>
-                {
-                    [nameof(genre)] = [$"'{genre}' is not a valid genre."]
-                });
-            }
-
-            parsedGenre = value;
-        }
-
-        var result = await mediator.Send(new GetTracksQuery(name, page.PageNumber, page.PageSize, parsedGenre), cancellationToken);
         return Results.Ok(result);
     }
 
@@ -146,7 +132,7 @@ public static class TrackEndpoints
         Guid id,
         CancellationToken cancellationToken)
     {
-        var result = await mediator.Send(new GetTrackStreamQuery(id, currentUser.Id), cancellationToken);
+        var result = await mediator.Send(new StartListeningCommand(id, currentUser.Id), cancellationToken);
         return result.ToHttpResult();
     }
 

backend/Hosts/Musify.Api/Models/GenreParameter.cs

@@ -0,0 +1,19 @@
+using Musify.Domain.ValueObjects;
+
+namespace Musify.Api.Models;
+
+/// <summary>Query-string binding for a genre name (case-insensitive); unknown names are rejected with a 400.</summary>
+public readonly record struct GenreParameter(Genre Value)
+{
+    public static bool TryParse(string? value, out GenreParameter result)
+    {
+        if (Enum.TryParse<Genre>(value, ignoreCase: true, out var genre) && Enum.IsDefined(genre))
+        {
+            result = new GenreParameter(genre);
+            return true;
+        }
+
+        result = default;
+        return false;
+    }
+}

backend/Hosts/Musify.Api/OpenApi/OpenApiOptionsSetup.cs

@@ -3,7 +3,6 @@ using Microsoft.AspNetCore.OpenApi;
 using Microsoft.Extensions.Options;
 using Microsoft.OpenApi;
 using Musify.Api.Authentication;
-using Musify.Application.Serialization;
 
 namespace Musify.Api.OpenApi;
 
@@ -41,10 +40,16 @@ public sealed class OpenApiOptionsSetup(IOptions<AuthenticationConfiguration> op
 
         options.AddSchemaTransformer((schema, context, _) =>
         {
-            if (context.JsonPropertyInfo?.CustomConverter is LongAsStringConverter or NullableLongAsStringConverter)
+            // Every long the API returns is a user id, serialized as a string (JS loses precision above 2^53).
+            // Request DTOs only carry byte sizes, which may be sent as numbers or strings.
+            if (context.JsonPropertyInfo is { } property
+                && (property.PropertyType == typeof(long) || property.PropertyType == typeof(long?)))
             {
-                schema.Type = JsonSchemaType.String;
+                var isRequest = property.DeclaringType?.Name.EndsWith("Request", StringComparison.Ordinal) == true;
-                schema.Format = null;
+                schema.Type = isRequest ? JsonSchemaType.Integer | JsonSchemaType.String : JsonSchemaType.String;
+                if (property.PropertyType == typeof(long?))
+                    schema.Type |= JsonSchemaType.Null;
+                schema.Format = isRequest ? "int64" : null;
             }
 
             return Task.CompletedTask;

backend/Hosts/Musify.Api/Program.cs

@@ -1,13 +1,18 @@
 using System.Text.Json.Serialization;
 using Musify.Api.Endpoints;
 using Musify.Api.Extensions;
+using Musify.Api.Serialization;
 using Musify.Infrastructure.Observability;
 using Scalar.AspNetCore;
 
 var builder = WebApplication.CreateBuilder();
 
 builder.Services.ConfigureHttpJsonOptions(options =>
-    options.SerializerOptions.Converters.Add(new JsonStringEnumConverter()));
+{
+    options.SerializerOptions.Converters.Add(new JsonStringEnumConverter());
+    options.SerializerOptions.Converters.Add(new LongAsStringConverter());
+    options.SerializerOptions.Converters.Add(new NullableLongAsStringConverter());
+});
 
 const string devCorsPolicy = "dev-cors";
 

backend/Hosts/Musify.Api/Serialization/LongAsStringConverter.cs

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

backend/Hosts/Musify.Api/Validators/AddTracksRequestValidator.cs

@@ -0,0 +1,20 @@
+using FluentValidation;
+using Musify.Api.DataTransferObjects;
+
+namespace Musify.Api.Validators;
+
+public sealed class AddTracksRequestValidator : AbstractValidator<AddTracksRequest>
+{
+    public const int MaxTracksPerRequest = 500;
+
+    public AddTracksRequestValidator()
+    {
+        RuleFor(x => x.TrackIds)
+            .NotEmpty()
+            .Must(ids => ids.Count <= MaxTracksPerRequest)
+            .WithMessage($"At most {MaxTracksPerRequest} tracks can be added at once.");
+
+        RuleForEach(x => x.TrackIds)
+            .NotEmpty();
+    }
+}

backend/Hosts/Musify.Api/Validators/Tracks/RecordListeningProgressRequestValidator.cs

@@ -0,0 +1,14 @@
+using FluentValidation;
+using Musify.Api.DataTransferObjects.Tracks;
+
+namespace Musify.Api.Validators.Tracks;
+
+public sealed class RecordListeningProgressRequestValidator : AbstractValidator<RecordListeningProgressRequest>
+{
+    public RecordListeningProgressRequestValidator()
+    {
+        RuleFor(x => x.PlayedSeconds)
+            .Must(seconds => double.IsFinite(seconds) && seconds >= 0)
+            .WithMessage("'Played Seconds' must be a non-negative number.");
+    }
+}

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

@@ -40,7 +40,6 @@ public sealed class GenreEndpointsTests(ApiTestFixture fixture)
             tag.TrackId = track.Id;
         database.Users.Add(owner);
         database.Tracks.Add(track);
-        database.UserHasTracks.Add(new UserHasTrack { UserId = owner.Id, TrackId = track.Id });
         await database.SaveChangesAsync(TestContext.Current.CancellationToken);
         return title;
     }

backend/Tests/Musify.Api.Tests/Validators/TrackRequestValidatorTests.cs

@@ -0,0 +1,48 @@
+using Musify.Api.DataTransferObjects.Tracks;
+using Musify.Api.Validators.Tracks;
+using Musify.Domain.ValueObjects;
+using Xunit;
+
+namespace Musify.Api.Tests.Validators;
+
+public sealed class TrackRequestValidatorTests
+{
+    [Fact]
+    public void CreateTrack_ValidRequest_Passes()
+    {
+        var request = new CreateTrackRequest("Song", Guid.NewGuid(), Guid.NewGuid(), [Genre.Pop, Genre.Rock]);
+
+        Assert.True(new CreateTrackRequestValidator().Validate(request).IsValid);
+    }
+
+    [Fact]
+    public void CreateTrack_NoTags_Fails()
+    {
+        var request = new CreateTrackRequest("Song", Guid.NewGuid(), Guid.NewGuid(), []);
+
+        Assert.False(new CreateTrackRequestValidator().Validate(request).IsValid);
+    }
+
+    [Fact]
+    public void CreateTrack_IncompatibleTags_Fails()
+    {
+        var request = new CreateTrackRequest("Song", Guid.NewGuid(), Guid.NewGuid(), [Genre.Classical, Genre.Metal]);
+
+        Assert.False(new CreateTrackRequestValidator().Validate(request).IsValid);
+    }
+
+    [Theory]
+    [InlineData(-1)]
+    [InlineData(double.NaN)]
+    [InlineData(double.PositiveInfinity)]
+    public void RecordListeningProgress_InvalidSeconds_Fails(double seconds)
+    {
+        Assert.False(new RecordListeningProgressRequestValidator().Validate(new RecordListeningProgressRequest(seconds)).IsValid);
+    }
+
+    [Fact]
+    public void RecordListeningProgress_ZeroSeconds_Passes()
+    {
+        Assert.True(new RecordListeningProgressRequestValidator().Validate(new RecordListeningProgressRequest(0)).IsValid);
+    }
+}

backend/Tests/Musify.Application.Tests/Albums/AddTracksToAlbumCommandHandlerTests.cs

@@ -7,9 +7,9 @@ using Xunit;
 
 namespace Musify.Application.Tests.Albums;
 
-public sealed class AddTrackToAlbumCommandHandlerTests : HandlerTestBase
+public sealed class AddTracksToAlbumCommandHandlerTests : HandlerTestBase
 {
-    private AddTrackToAlbumCommandHandler CreateHandler() => new(Database, NoOpLogger<AddTrackToAlbumCommandHandler>());
+    private AddTracksToAlbumCommandHandler CreateHandler() => new(Database, NoOpLogger<AddTracksToAlbumCommandHandler>());
 
     [Fact]
     public async Task Handle_FirstTrack_AddsItAtNumberOne()
@@ -19,7 +19,7 @@ public sealed class AddTrackToAlbumCommandHandlerTests : HandlerTestBase
         var track = TestEntities.Track(owner);
         await SeedAsync(owner, album, track);
 
-        var result = await CreateHandler().Handle(new AddTrackToAlbumCommand(owner.Id, album.Id, track.Id), TestContext.Current.CancellationToken);
+        var result = await CreateHandler().Handle(new AddTracksToAlbumCommand(owner.Id, album.Id, [track.Id]), TestContext.Current.CancellationToken);
 
         Assert.False(result.IsError);
         var link = Assert.Single(await Database.AlbumHasTracks.ToListAsync(TestContext.Current.CancellationToken));
@@ -33,7 +33,7 @@ public sealed class AddTrackToAlbumCommandHandlerTests : HandlerTestBase
         var track = TestEntities.Track(owner);
         await SeedAsync(owner, track);
 
-        var result = await CreateHandler().Handle(new AddTrackToAlbumCommand(owner.Id, Guid.NewGuid(), track.Id), TestContext.Current.CancellationToken);
+        var result = await CreateHandler().Handle(new AddTracksToAlbumCommand(owner.Id, Guid.NewGuid(), [track.Id]), TestContext.Current.CancellationToken);
 
         Assert.Equal(ErrorType.NotFound, result.FirstError.Type);
     }
@@ -47,7 +47,7 @@ public sealed class AddTrackToAlbumCommandHandlerTests : HandlerTestBase
         var track = TestEntities.Track(owner);
         await SeedAsync(owner, stranger, album, track);
 
-        var result = await CreateHandler().Handle(new AddTrackToAlbumCommand(stranger.Id, album.Id, track.Id), TestContext.Current.CancellationToken);
+        var result = await CreateHandler().Handle(new AddTracksToAlbumCommand(stranger.Id, album.Id, [track.Id]), TestContext.Current.CancellationToken);
 
         Assert.Equal(ErrorType.Forbidden, result.FirstError.Type);
     }
@@ -59,7 +59,7 @@ public sealed class AddTrackToAlbumCommandHandlerTests : HandlerTestBase
         var album = TestEntities.Album(owner.Id);
         await SeedAsync(owner, album);
 
-        var result = await CreateHandler().Handle(new AddTrackToAlbumCommand(owner.Id, album.Id, Guid.NewGuid()), TestContext.Current.CancellationToken);
+        var result = await CreateHandler().Handle(new AddTracksToAlbumCommand(owner.Id, album.Id, [Guid.NewGuid()]), TestContext.Current.CancellationToken);
 
         Assert.Equal(ErrorType.NotFound, result.FirstError.Type);
     }
@@ -73,13 +73,13 @@ public sealed class AddTrackToAlbumCommandHandlerTests : HandlerTestBase
         var foreignTrack = TestEntities.Track(otherOwner);
         await SeedAsync(owner, otherOwner, album, foreignTrack);
 
-        var result = await CreateHandler().Handle(new AddTrackToAlbumCommand(owner.Id, album.Id, foreignTrack.Id), TestContext.Current.CancellationToken);
+        var result = await CreateHandler().Handle(new AddTracksToAlbumCommand(owner.Id, album.Id, [foreignTrack.Id]), TestContext.Current.CancellationToken);
 
         Assert.Equal(ErrorType.Forbidden, result.FirstError.Type);
     }
 
     [Fact]
-    public async Task Handle_AlreadyInAlbum_ReturnsConflict()
+    public async Task Handle_AlreadyInAlbum_IsSkipped()
     {
         var owner = TestEntities.User();
         var album = TestEntities.Album(owner.Id);
@@ -87,9 +87,10 @@ public sealed class AddTrackToAlbumCommandHandlerTests : HandlerTestBase
         var link = new AlbumHasTrack { AlbumId = album.Id, TrackId = track.Id, TrackNumber = 1 };
         await SeedAsync(owner, album, track, link);
 
-        var result = await CreateHandler().Handle(new AddTrackToAlbumCommand(owner.Id, album.Id, track.Id), TestContext.Current.CancellationToken);
+        var result = await CreateHandler().Handle(new AddTracksToAlbumCommand(owner.Id, album.Id, [track.Id]), TestContext.Current.CancellationToken);
 
-        Assert.Equal(ErrorType.Conflict, result.FirstError.Type);
+        Assert.False(result.IsError);
+        Assert.Single(await Database.AlbumHasTracks.ToListAsync(TestContext.Current.CancellationToken));
     }
 
     [Fact]
@@ -102,7 +103,7 @@ public sealed class AddTrackToAlbumCommandHandlerTests : HandlerTestBase
         var existingLink = new AlbumHasTrack { AlbumId = album.Id, TrackId = firstTrack.Id, TrackNumber = 3 };
         await SeedAsync(owner, album, firstTrack, secondTrack, existingLink);
 
-        var result = await CreateHandler().Handle(new AddTrackToAlbumCommand(owner.Id, album.Id, secondTrack.Id), TestContext.Current.CancellationToken);
+        var result = await CreateHandler().Handle(new AddTracksToAlbumCommand(owner.Id, album.Id, [secondTrack.Id]), TestContext.Current.CancellationToken);
 
         Assert.False(result.IsError);
         var newLink = await Database.AlbumHasTracks.SingleAsync(l => l.TrackId == secondTrack.Id, TestContext.Current.CancellationToken);

backend/Tests/Musify.Application.Tests/Genres/GetGenresQueryHandlerTests.cs

@@ -1,6 +1,5 @@
 using Musify.Application.Genres;
 using Musify.Application.Tests.TestSupport;
-using Musify.Domain.Entities;
 using Musify.Domain.ValueObjects;
 using Xunit;
 
@@ -26,10 +25,7 @@ public sealed class GetGenresQueryHandlerTests : HandlerTestBase
         var rockB = TestEntities.Track(owner, "Rock B", tags: [Genre.Rock, Genre.Indie]);
         var jazz = TestEntities.Track(owner, "Jazz", tags: [Genre.Jazz]);
         await SeedAsync(
-            owner, rockA, rockB, jazz,
+            owner, rockA, rockB, jazz);
-            new UserHasTrack { UserId = owner.Id, TrackId = rockA.Id },
-            new UserHasTrack { UserId = owner.Id, TrackId = rockB.Id },
-            new UserHasTrack { UserId = owner.Id, TrackId = jazz.Id });
 
         var result = await CreateHandler().Handle(new GetGenresQuery(), TestContext.Current.CancellationToken);
 
@@ -38,31 +34,4 @@ public sealed class GetGenresQueryHandlerTests : HandlerTestBase
             result.Select(r => (r.Genre, r.TrackCount)));
     }
 
-    [Fact]
-    public async Task Handle_TrackInSeveralLibraries_IsCountedOnce()
-    {
-        var owner = TestEntities.User();
-        var other = TestEntities.User(id: 2, name: "other-user");
-        var track = TestEntities.Track(owner, tags: [Genre.Pop]);
-        await SeedAsync(
-            owner, other, track,
-            new UserHasTrack { UserId = owner.Id, TrackId = track.Id },
-            new UserHasTrack { UserId = other.Id, TrackId = track.Id });
-
-        var result = await CreateHandler().Handle(new GetGenresQuery(), TestContext.Current.CancellationToken);
-
-        Assert.Equal(1, Assert.Single(result).TrackCount);
-    }
-
-    [Fact]
-    public async Task Handle_TrackNotInAnyLibrary_IsIgnored()
-    {
-        var owner = TestEntities.User();
-        var track = TestEntities.Track(owner, tags: [Genre.Metal]);
-        await SeedAsync(owner, track);
-
-        var result = await CreateHandler().Handle(new GetGenresQuery(), TestContext.Current.CancellationToken);
-
-        Assert.Empty(result);
-    }
 }

backend/Tests/Musify.Application.Tests/Mixes/GenerateMixesForUserCommandHandlerTests.cs

@@ -1,7 +1,7 @@
 using Microsoft.EntityFrameworkCore;
 using Musify.Application.Mixes;
 using Musify.Application.Tests.TestSupport;
-using Musify.Domain.Entities;
+using Musify.Domain.ValueObjects;
 using Xunit;
 
 namespace Musify.Application.Tests.Mixes;
@@ -30,7 +30,6 @@ public sealed class GenerateMixesForUserCommandHandlerTests : HandlerTestBase
         var track = TestEntities.Track(user);
         await SeedAsync(
             user, track,
-            new UserHasTrack { UserId = user.Id, TrackId = track.Id },
             TestEntities.ListeningHistory(user.Id, track.Id));
 
         var result = await CreateHandler().Handle(new GenerateMixesForUserCommand(user.Id), TestContext.Current.CancellationToken);
@@ -38,7 +37,7 @@ public sealed class GenerateMixesForUserCommandHandlerTests : HandlerTestBase
         Assert.False(result.IsError);
         var mixes = await Database.Mixes.ToListAsync(TestContext.Current.CancellationToken);
         Assert.Single(mixes);
-        Assert.Equal("Tu mezcla diaria", mixes[0].Title);
+        Assert.Equal(MixKind.Daily, mixes[0].Kind);
     }
 
     [Fact]
@@ -48,25 +47,23 @@ public sealed class GenerateMixesForUserCommandHandlerTests : HandlerTestBase
         var listenedTrack = TestEntities.Track(user, "Listened Track");
         var unheardTrack = TestEntities.Track(user, "Unheard Track");
 
-        var staleMix = TestEntities.Mix(user.Id, "Stale Mix");
+        var staleMix = TestEntities.Mix(user.Id, MixKind.Daily);
         var staleItem = TestEntities.MixItem(staleMix.Id, listenedTrack.Id);
 
         await SeedAsync(
             user, listenedTrack, unheardTrack, staleMix, staleItem,
-            new UserHasTrack { UserId = user.Id, TrackId = listenedTrack.Id },
-            new UserHasTrack { UserId = user.Id, TrackId = unheardTrack.Id },
             TestEntities.ListeningHistory(user.Id, listenedTrack.Id));
 
         var result = await CreateHandler().Handle(new GenerateMixesForUserCommand(user.Id), TestContext.Current.CancellationToken);
 
         Assert.False(result.IsError);
         var mixes = await Database.Mixes.ToListAsync(TestContext.Current.CancellationToken);
-        Assert.DoesNotContain(mixes, mix => mix.Title == "Stale Mix");
+        Assert.DoesNotContain(mixes, mix => mix.Id == staleMix.Id);
-        Assert.Contains(mixes, mix => mix.Title == "Descubrimiento");
+        Assert.Contains(mixes, mix => mix.Kind == MixKind.Discovery);
-        Assert.Contains(mixes, mix => mix.Title == "Tu mezcla diaria");
+        Assert.Contains(mixes, mix => mix.Kind == MixKind.Daily);
         Assert.Empty(await Database.MixItems.Where(item => item.MixId == staleMix.Id).ToListAsync(TestContext.Current.CancellationToken));
 
-        var discoveryMix = mixes.Single(mix => mix.Title == "Descubrimiento");
+        var discoveryMix = mixes.Single(mix => mix.Kind == MixKind.Discovery);
         var discoveryItems = await Database.MixItems
             .Where(item => item.MixId == discoveryMix.Id)
             .ToListAsync(TestContext.Current.CancellationToken);
@@ -80,12 +77,11 @@ public sealed class GenerateMixesForUserCommandHandlerTests : HandlerTestBase
         var skipped = TestEntities.Track(user, "Only skipped");
         await SeedAsync(
             user, skipped,
-            new UserHasTrack { UserId = user.Id, TrackId = skipped.Id },
             TestEntities.ListeningHistory(user.Id, skipped.Id, playedSeconds: 3, isCounted: false));
 
         await CreateHandler().Handle(new GenerateMixesForUserCommand(user.Id), TestContext.Current.CancellationToken);
 
         var mixes = await Database.Mixes.ToListAsync(TestContext.Current.CancellationToken);
-        Assert.Contains(mixes, mix => mix.Title == "Descubrimiento");
+        Assert.Contains(mixes, mix => mix.Kind == MixKind.Discovery);
     }
 }

backend/Tests/Musify.Application.Tests/Mixes/GetMixByIdQueryHandlerTests.cs

@@ -1,6 +1,7 @@
 using ErrorOr;
 using Musify.Application.Mixes;
 using Musify.Application.Tests.TestSupport;
+using Musify.Domain.ValueObjects;
 using Xunit;
 
 namespace Musify.Application.Tests.Mixes;
@@ -15,7 +16,7 @@ public sealed class GetMixByIdQueryHandlerTests : HandlerTestBase
         var owner = TestEntities.User();
         var firstTrack = TestEntities.Track(owner, "First");
         var secondTrack = TestEntities.Track(owner, "Second");
-        var mix = TestEntities.Mix(owner.Id, "Discovery");
+        var mix = TestEntities.Mix(owner.Id, MixKind.Daily);
         var second = TestEntities.MixItem(mix.Id, secondTrack.Id, position: 1);
         var first = TestEntities.MixItem(mix.Id, firstTrack.Id, position: 0);
         await SeedAsync(owner, firstTrack, secondTrack, mix, second, first);
@@ -23,7 +24,7 @@ public sealed class GetMixByIdQueryHandlerTests : HandlerTestBase
         var result = await CreateHandler().Handle(new GetMixByIdQuery(owner.Id, mix.Id), TestContext.Current.CancellationToken);
 
         Assert.False(result.IsError);
-        Assert.Equal("Discovery", result.Value.Title);
+        Assert.Equal(MixKind.Daily, result.Value.Kind);
         Assert.Equal(["First", "Second"], result.Value.Items.Select(item => item.Title));
     }
 

backend/Tests/Musify.Application.Tests/Mixes/GetMixesByUserIdQueryHandlerTests.cs

@@ -1,5 +1,6 @@
 using Musify.Application.Mixes;
 using Musify.Application.Tests.TestSupport;
+using Musify.Domain.ValueObjects;
 using Xunit;
 
 namespace Musify.Application.Tests.Mixes;
@@ -13,13 +14,13 @@ public sealed class GetMixesByUserIdQueryHandlerTests : HandlerTestBase
     {
         var owner = TestEntities.User(1, "owner");
         var other = TestEntities.User(2, "other");
-        var second = TestEntities.Mix(owner.Id, "Second", position: 1);
+        var second = TestEntities.Mix(owner.Id, MixKind.Daily, position: 1);
-        var first = TestEntities.Mix(owner.Id, "First", position: 0);
+        var first = TestEntities.Mix(owner.Id, MixKind.Discovery, position: 0);
-        var theirs = TestEntities.Mix(other.Id, "Theirs");
+        var theirs = TestEntities.Mix(other.Id);
         await SeedAsync(owner, other, second, first, theirs);
 
         var result = await CreateHandler().Handle(new GetMixesByUserIdQuery(owner.Id), TestContext.Current.CancellationToken);
-        Assert.Equal(["First", "Second"], result.Select(mix => mix.Title));
+        Assert.Equal([MixKind.Discovery, MixKind.Daily], result.Select(mix => mix.Kind));
     }
 
     [Fact]

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

@@ -7,9 +7,9 @@ using Xunit;
 
 namespace Musify.Application.Tests.PlayLists;
 
-public sealed class AddTrackToPlayListCommandHandlerTests : HandlerTestBase
+public sealed class AddTracksToPlayListCommandHandlerTests : HandlerTestBase
 {
-    private AddTrackToPlayListCommandHandler CreateHandler() => new(Database, NoOpLogger<AddTrackToPlayListCommandHandler>());
+    private AddTracksToPlayListCommandHandler CreateHandler() => new(Database, NoOpLogger<AddTracksToPlayListCommandHandler>());
 
     [Fact]
     public async Task Handle_FirstTrack_AddsItAtPositionZero()
@@ -19,7 +19,7 @@ public sealed class AddTrackToPlayListCommandHandlerTests : HandlerTestBase
         var track = TestEntities.Track(owner);
         await SeedAsync(owner, playList, track);
 
-        var result = await CreateHandler().Handle(new AddTrackToPlayListCommand(owner.Id, playList.Id, track.Id), TestContext.Current.CancellationToken);
+        var result = await CreateHandler().Handle(new AddTracksToPlayListCommand(owner.Id, playList.Id, [track.Id]), TestContext.Current.CancellationToken);
 
         Assert.False(result.IsError);
         var link = Assert.Single(await Database.PlayListHasTracks.ToListAsync(TestContext.Current.CancellationToken));
@@ -37,7 +37,7 @@ public sealed class AddTrackToPlayListCommandHandlerTests : HandlerTestBase
             owner, playList, existingTrack, newTrack,
             new PlayListHasTrack { PlayListId = playList.Id, TrackId = existingTrack.Id, Position = 0 });
 
-        var result = await CreateHandler().Handle(new AddTrackToPlayListCommand(owner.Id, playList.Id, newTrack.Id), TestContext.Current.CancellationToken);
+        var result = await CreateHandler().Handle(new AddTracksToPlayListCommand(owner.Id, playList.Id, [newTrack.Id]), TestContext.Current.CancellationToken);
 
         Assert.False(result.IsError);
         var newLink = await Database.PlayListHasTracks.SingleAsync(link => link.TrackId == newTrack.Id, TestContext.Current.CancellationToken);
@@ -47,7 +47,7 @@ public sealed class AddTrackToPlayListCommandHandlerTests : HandlerTestBase
     [Fact]
     public async Task Handle_PlayListMissing_ReturnsNotFound()
     {
-        var result = await CreateHandler().Handle(new AddTrackToPlayListCommand(1, Guid.NewGuid(), Guid.NewGuid()), TestContext.Current.CancellationToken);
+        var result = await CreateHandler().Handle(new AddTracksToPlayListCommand(1, Guid.NewGuid(), [Guid.NewGuid()]), TestContext.Current.CancellationToken);
 
         Assert.Equal(ErrorType.NotFound, result.FirstError.Type);
     }
@@ -60,7 +60,7 @@ public sealed class AddTrackToPlayListCommandHandlerTests : HandlerTestBase
         var playList = TestEntities.PlayList(owner.Id);
         await SeedAsync(owner, stranger, playList);
 
-        var result = await CreateHandler().Handle(new AddTrackToPlayListCommand(stranger.Id, playList.Id, Guid.NewGuid()), TestContext.Current.CancellationToken);
+        var result = await CreateHandler().Handle(new AddTracksToPlayListCommand(stranger.Id, playList.Id, [Guid.NewGuid()]), TestContext.Current.CancellationToken);
 
         Assert.Equal(ErrorType.Forbidden, result.FirstError.Type);
     }
@@ -72,22 +72,23 @@ public sealed class AddTrackToPlayListCommandHandlerTests : HandlerTestBase
         var playList = TestEntities.PlayList(owner.Id);
         await SeedAsync(owner, playList);
 
-        var result = await CreateHandler().Handle(new AddTrackToPlayListCommand(owner.Id, playList.Id, Guid.NewGuid()), TestContext.Current.CancellationToken);
+        var result = await CreateHandler().Handle(new AddTracksToPlayListCommand(owner.Id, playList.Id, [Guid.NewGuid()]), TestContext.Current.CancellationToken);
 
         Assert.Equal(ErrorType.NotFound, result.FirstError.Type);
     }
 
     [Fact]
-    public async Task Handle_TrackAlreadyInPlayList_ReturnsConflict()
+    public async Task Handle_TrackAlreadyInPlayList_IsSkipped()
     {
         var owner = TestEntities.User();
         var playList = TestEntities.PlayList(owner.Id);
         var track = TestEntities.Track(owner);
         await SeedAsync(owner, playList, track, new PlayListHasTrack { PlayListId = playList.Id, TrackId = track.Id, Position = 0 });
 
-        var result = await CreateHandler().Handle(new AddTrackToPlayListCommand(owner.Id, playList.Id, track.Id), TestContext.Current.CancellationToken);
+        var result = await CreateHandler().Handle(new AddTracksToPlayListCommand(owner.Id, playList.Id, [track.Id]), TestContext.Current.CancellationToken);
 
-        Assert.Equal(ErrorType.Conflict, result.FirstError.Type);
+        Assert.False(result.IsError);
+        Assert.Single(await Database.PlayListHasTracks.ToListAsync(TestContext.Current.CancellationToken));
     }
 
     [Fact]
@@ -103,4 +104,26 @@ public sealed class AddTrackToPlayListCommandHandlerTests : HandlerTestBase
 
         Assert.Equal("Test.Duplicate", result.FirstError.Code);
     }
+
+    [Fact]
+    public async Task Handle_SeveralTracks_AppendsThemInOrderSkippingExistingOnes()
+    {
+        var owner = TestEntities.User();
+        var playList = TestEntities.PlayList(owner.Id);
+        var existing = TestEntities.Track(owner, "Existing");
+        var first = TestEntities.Track(owner, "First");
+        var second = TestEntities.Track(owner, "Second");
+        await SeedAsync(
+            owner, playList, existing, first, second,
+            new PlayListHasTrack { PlayListId = playList.Id, TrackId = existing.Id, Position = 0 });
+
+        var result = await CreateHandler().Handle(
+            new AddTracksToPlayListCommand(owner.Id, playList.Id, [first.Id, existing.Id, second.Id, first.Id]),
+            TestContext.Current.CancellationToken);
+
+        Assert.False(result.IsError);
+        var links = await Database.PlayListHasTracks.OrderBy(link => link.Position).ToListAsync(TestContext.Current.CancellationToken);
+        Assert.Equal([existing.Id, first.Id, second.Id], links.Select(link => link.TrackId));
+        Assert.Equal([0, 1, 2], links.Select(link => link.Position));
+    }
 }

backend/Tests/Musify.Application.Tests/Services/TrackStreamIssuerTests.cs

@@ -1,4 +1,3 @@
-using Microsoft.EntityFrameworkCore;
 using Musify.Application.Configuration;
 using Musify.Application.Contracts;
 using Musify.Application.Services;
@@ -8,90 +7,56 @@ using Xunit;
 
 namespace Musify.Application.Tests.Services;
 
-public sealed class TrackStreamIssuerTests : HandlerTestBase
+public sealed class TrackStreamIssuerTests
 {
     private readonly IStreamTicketService ticketService = Substitute.For<IStreamTicketService>();
 
+    public TrackStreamIssuerTests() =>
+        ticketService.IssueTicket(Arg.Any<long?>(), Arg.Any<string>(), Arg.Any<long?>()).Returns(new StreamTicket("signed-token", 120));
+
     private TrackStreamIssuer CreateIssuer(PlaybackConfiguration? playback = null) => new(
-        Database,
         ticketService,
         TestConfigurations.Track(),
         TestConfigurations.StreamGateway("https://stream.musify.test/"),
         playback ?? TestConfigurations.Playback());
 
     [Fact]
-    public async Task IssueAsync_BuildsManifestUrlAndRecordsListeningHistory()
+    public void Issue_BuildsManifestUrlAndCarriesTheListenId()
     {
-        ticketService.IssueTicket(7, Arg.Any<string>(), Arg.Any<long?>()).Returns(new StreamTicket("signed-token", 120));
+        var listenId = Guid.NewGuid();
-        var owner = TestEntities.User(7);
-        var track = TestEntities.Track(owner);
-        await SeedAsync(owner, track);
 
-        var response = await CreateIssuer().IssueAsync(track.Id, "folder-42", userId: 7, TestContext.Current.CancellationToken);
+        var response = CreateIssuer().Issue("folder-42", userId: 7, listenId);
 
         Assert.Equal("signed-token", response.Ticket);
         Assert.Equal(120, response.ExpiresInSeconds);
-        Assert.Equal(
+        Assert.Equal(listenId, response.ListenId);
-            "https://stream.musify.test/media/Tracks/ProcessedAudios/folder-42/audio.m4a",
+        Assert.Equal("https://stream.musify.test/media/Tracks/ProcessedAudios/folder-42/audio.m4a", response.ManifestUrl);
-            response.ManifestUrl);
-
-        var history = Assert.Single(await Database.ListeningHistories.ToListAsync(TestContext.Current.CancellationToken));
-        Assert.Equal(7, history.UserId);
-        Assert.Equal(track.Id, history.TrackId);
     }
 
     [Fact]
-    public async Task IssueAsync_PassesTheProcessedAudioKeyPrefixToTheTicketService()
+    public void Issue_PassesTheProcessedAudioKeyPrefixToTheTicketService()
     {
-        ticketService.IssueTicket(Arg.Any<long?>(), Arg.Any<string>(), Arg.Any<long?>()).Returns(new StreamTicket("token", 60));
+        CreateIssuer().Issue("folder-42", userId: 1, listenId: null);
-        var owner = TestEntities.User(1);
-        var track = TestEntities.Track(owner);
-        await SeedAsync(owner, track);
-
-        await CreateIssuer().IssueAsync(track.Id, "folder-42", userId: 1, TestContext.Current.CancellationToken);
 
         ticketService.Received(1).IssueTicket(1, "Tracks/ProcessedAudios/folder-42/", null);
     }
 
     [Fact]
-    public async Task IssueAsync_AnonymousUser_SkipsListeningHistoryAndNeverThrows()
+    public void Issue_AnonymousUserWithFragmentConfigured_PassesTheByteCapToTheTicketService()
     {
-        ticketService.IssueTicket(Arg.Any<long?>(), Arg.Any<string>(), Arg.Any<long?>()).Returns(new StreamTicket("token", 60));
-        var owner = TestEntities.User(1);
-        var track = TestEntities.Track(owner);
-        await SeedAsync(owner, track);
-
-        var response = await CreateIssuer(TestConfigurations.Playback(allowAnonymousListening: true))
-            .IssueAsync(track.Id, "folder-42", userId: null, TestContext.Current.CancellationToken);
-
-        Assert.Equal("token", response.Ticket);
-        Assert.Empty(await Database.ListeningHistories.ToListAsync(TestContext.Current.CancellationToken));
-    }
-
-    [Fact]
-    public async Task IssueAsync_AnonymousUserWithFragmentConfigured_PassesTheByteCapToTheTicketService()
-    {
-        ticketService.IssueTicket(Arg.Any<long?>(), Arg.Any<string>(), Arg.Any<long?>()).Returns(new StreamTicket("token", 60));
-        var owner = TestEntities.User(1);
-        var track = TestEntities.Track(owner);
-        await SeedAsync(owner, track);
-
         var playback = TestConfigurations.Playback(allowAnonymousListening: true, anonymousFragmentSeconds: 30);
-        await CreateIssuer(playback).IssueAsync(track.Id, "folder-42", userId: null, TestContext.Current.CancellationToken);
+
+        CreateIssuer(playback).Issue("folder-42", userId: null, listenId: null);
 
         ticketService.Received(1).IssueTicket(null, "Tracks/ProcessedAudios/folder-42/", 30L * playback.EstimatedAudioBytesPerSecond);
     }
 
     [Fact]
-    public async Task IssueAsync_AuthenticatedUser_IgnoresTheAnonymousFragmentCap()
+    public void Issue_AuthenticatedUser_IgnoresTheAnonymousFragmentCap()
     {
-        ticketService.IssueTicket(Arg.Any<long?>(), Arg.Any<string>(), Arg.Any<long?>()).Returns(new StreamTicket("token", 60));
-        var owner = TestEntities.User(1);
-        var track = TestEntities.Track(owner);
-        await SeedAsync(owner, track);
-
         var playback = TestConfigurations.Playback(allowAnonymousListening: true, anonymousFragmentSeconds: 30);
-        await CreateIssuer(playback).IssueAsync(track.Id, "folder-42", userId: 1, TestContext.Current.CancellationToken);
+
+        CreateIssuer(playback).Issue("folder-42", userId: 1, listenId: null);
 
         ticketService.Received(1).IssueTicket(1, "Tracks/ProcessedAudios/folder-42/", null);
     }

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

@@ -143,8 +143,6 @@ public sealed class TestDatabase : DbContext, IDatabase
 
     public DbSet<Track> Tracks => Set<Track>();
 
-    public DbSet<UserHasTrack> UserHasTracks => Set<UserHasTrack>();
-
     public DbSet<PlayListHasTrack> PlayListHasTracks => Set<PlayListHasTrack>();
 
     public DbSet<Mix> Mixes => Set<Mix>();

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

@@ -154,14 +154,12 @@ public static class TestEntities
 
     public static Mix Mix(
         long userId,
-        string title = "Test Mix",
+        MixKind kind = MixKind.Discovery,
-        string? subtitle = null,
         int position = 0) =>
         new()
         {
             UserId = userId,
-            Title = title,
+            Kind = kind,
-            Subtitle = subtitle,
             Position = position
         };
 

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

@@ -89,34 +89,6 @@ public sealed class CreateTrackCommandHandlerTests : HandlerTestBase
         Assert.Equal(isExplicit, stored.IsExplicit);
     }
 
-    [Fact]
-    public async Task Handle_NoTags_ReturnsValidationError()
-    {
-        var user = TestEntities.User();
-        var (picture, audio) = SeedIntents(user.Id);
-        await SeedAsync(user, picture, audio);
-
-        var command = new CreateTrackCommand(user.Id, "My Song", picture.Id, audio.Id, []);
-
-        var result = await CreateHandler().Handle(command, TestContext.Current.CancellationToken);
-
-        Assert.Equal(ErrorType.Validation, result.FirstError.Type);
-    }
-
-    [Fact]
-    public async Task Handle_IncompatibleTags_ReturnsValidationError()
-    {
-        var user = TestEntities.User();
-        var (picture, audio) = SeedIntents(user.Id);
-        await SeedAsync(user, picture, audio);
-
-        var command = new CreateTrackCommand(user.Id, "My Song", picture.Id, audio.Id, [Genre.Classical, Genre.Metal]);
-
-        var result = await CreateHandler().Handle(command, TestContext.Current.CancellationToken);
-
-        Assert.Equal(ErrorType.Validation, result.FirstError.Type);
-    }
-
     [Fact]
     public async Task Handle_UserMissing_ReturnsNotFound()
     {

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

@@ -1,6 +1,5 @@
 using Musify.Application.Tests.TestSupport;
 using Musify.Application.Tracks;
-using Musify.Domain.Entities;
 using Xunit;
 
 namespace Musify.Application.Tests.Tracks;
@@ -17,9 +16,7 @@ public sealed class GetTracksByUserIdQueryHandlerTests : HandlerTestBase
         var mine = TestEntities.Track(owner, "Mine");
         var theirs = TestEntities.Track(other, "Theirs");
         await SeedAsync(
-            owner, other, mine, theirs,
+            owner, other, mine, theirs);
-            new UserHasTrack { UserId = owner.Id, TrackId = mine.Id },
-            new UserHasTrack { UserId = other.Id, TrackId = theirs.Id });
 
         var result = await CreateHandler().Handle(new GetTracksByUserIdQuery(owner.Id, Name: null, PageNumber: 1, PageSize: 10), TestContext.Current.CancellationToken);
 

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

@@ -16,9 +16,7 @@ public sealed class GetTracksQueryHandlerTests : HandlerTestBase
         var trackA = TestEntities.Track(owner, "Alpha");
         var trackB = TestEntities.Track(owner, "Beta");
         await SeedAsync(
-            owner, trackA, trackB,
+            owner, trackA, trackB);
-            new Musify.Domain.Entities.UserHasTrack { UserId = owner.Id, TrackId = trackA.Id },
-            new Musify.Domain.Entities.UserHasTrack { UserId = owner.Id, TrackId = trackB.Id });
 
         var result = await CreateHandler().Handle(new GetTracksQuery(Name: null, PageNumber: 1, PageSize: 10), TestContext.Current.CancellationToken);
         Assert.Equal(2, result.TotalItemCount);
@@ -32,9 +30,7 @@ public sealed class GetTracksQueryHandlerTests : HandlerTestBase
         var match = TestEntities.Track(owner, "Bohemian Rhapsody");
         var other = TestEntities.Track(owner, "Imagine");
         await SeedAsync(
-            owner, match, other,
+            owner, match, other);
-            new Musify.Domain.Entities.UserHasTrack { UserId = owner.Id, TrackId = match.Id },
-            new Musify.Domain.Entities.UserHasTrack { UserId = owner.Id, TrackId = other.Id });
 
         var result = await CreateHandler().Handle(new GetTracksQuery(Name: "rhapsody", PageNumber: 1, PageSize: 10), TestContext.Current.CancellationToken);
         var item = Assert.Single(result.Items);
@@ -48,9 +44,7 @@ public sealed class GetTracksQueryHandlerTests : HandlerTestBase
         var rock = TestEntities.Track(owner, "Loud", tags: [Genre.Rock, Genre.Indie]);
         var jazz = TestEntities.Track(owner, "Smooth", tags: [Genre.Jazz]);
         await SeedAsync(
-            owner, rock, jazz,
+            owner, rock, jazz);
-            new Musify.Domain.Entities.UserHasTrack { UserId = owner.Id, TrackId = rock.Id },
-            new Musify.Domain.Entities.UserHasTrack { UserId = owner.Id, TrackId = jazz.Id });
 
         var result = await CreateHandler().Handle(new GetTracksQuery(null, 1, 10, Genre.Indie), TestContext.Current.CancellationToken);
         var item = Assert.Single(result.Items);

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

@@ -110,17 +110,4 @@ public sealed class RecordListeningProgressCommandHandlerTests : HandlerTestBase
         Assert.Equal(ErrorType.NotFound, result.FirstError.Type);
     }
 
-    [Theory]
-    [InlineData(-1)]
-    [InlineData(double.NaN)]
-    [InlineData(double.PositiveInfinity)]
-    public async Task Handle_InvalidSeconds_ReturnsValidationError(double seconds)
-    {
-        var (user, listen) = await SeedListenAsync(200, DateTime.UtcNow.AddSeconds(-60));
-
-        var result = await CreateHandler().Handle(
-            new RecordListeningProgressCommand(user.Id, listen.Id, seconds), TestContext.Current.CancellationToken);
-
-        Assert.Equal(ErrorType.Validation, result.FirstError.Type);
-    }
 }

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

@@ -10,22 +10,21 @@ using Xunit;
 
 namespace Musify.Application.Tests.Tracks;
 
-public sealed class GetTrackStreamQueryHandlerTests : HandlerTestBase
+public sealed class StartListeningCommandHandlerTests : HandlerTestBase
 {
     private readonly IStreamTicketService ticketService = Substitute.For<IStreamTicketService>();
 
-    private GetTrackStreamQueryHandler CreateHandler(PlaybackConfiguration? playback = null)
+    private StartListeningCommandHandler CreateHandler(PlaybackConfiguration? playback = null)
     {
         ticketService.IssueTicket(Arg.Any<long?>(), Arg.Any<string>(), Arg.Any<long?>()).Returns(new StreamTicket("ticket-token", 60));
 
         var issuer = new TrackStreamIssuer(
-            Database,
             ticketService,
             TestConfigurations.Track(),
             TestConfigurations.StreamGateway("https://stream.musify.test"),
             playback ?? TestConfigurations.Playback());
 
-        return new GetTrackStreamQueryHandler(Database, issuer, playback ?? TestConfigurations.Playback(), NoOpLogger<GetTrackStreamQueryHandler>());
+        return new StartListeningCommandHandler(Database, issuer, playback ?? TestConfigurations.Playback(), NoOpLogger<StartListeningCommandHandler>());
     }
 
     [Fact]
@@ -35,7 +34,7 @@ public sealed class GetTrackStreamQueryHandlerTests : HandlerTestBase
         var track = TestEntities.Track(owner);
         await SeedAsync(owner, track);
 
-        var result = await CreateHandler().Handle(new GetTrackStreamQuery(track.Id, owner.Id), TestContext.Current.CancellationToken);
+        var result = await CreateHandler().Handle(new StartListeningCommand(track.Id, owner.Id), TestContext.Current.CancellationToken);
 
         Assert.False(result.IsError);
         Assert.Equal("ticket-token", result.Value.Ticket);
@@ -53,7 +52,7 @@ public sealed class GetTrackStreamQueryHandlerTests : HandlerTestBase
     [Fact]
     public async Task Handle_TrackMissing_ReturnsNotFound()
     {
-        var result = await CreateHandler().Handle(new GetTrackStreamQuery(Guid.NewGuid(), 1), TestContext.Current.CancellationToken);
+        var result = await CreateHandler().Handle(new StartListeningCommand(Guid.NewGuid(), 1), TestContext.Current.CancellationToken);
 
         Assert.Equal(ErrorType.NotFound, result.FirstError.Type);
     }
@@ -65,7 +64,7 @@ public sealed class GetTrackStreamQueryHandlerTests : HandlerTestBase
         var track = TestEntities.Track(owner, audio: TestEntities.PendingAudio());
         await SeedAsync(owner, track);
 
-        var result = await CreateHandler().Handle(new GetTrackStreamQuery(track.Id, owner.Id), TestContext.Current.CancellationToken);
+        var result = await CreateHandler().Handle(new StartListeningCommand(track.Id, owner.Id), TestContext.Current.CancellationToken);
 
         Assert.Equal(ErrorType.Conflict, result.FirstError.Type);
     }
@@ -79,7 +78,7 @@ public sealed class GetTrackStreamQueryHandlerTests : HandlerTestBase
 
         var handler = CreateHandler(TestConfigurations.Playback(allowAnonymousListening: false));
 
-        var result = await handler.Handle(new GetTrackStreamQuery(track.Id, UserId: null), TestContext.Current.CancellationToken);
+        var result = await handler.Handle(new StartListeningCommand(track.Id, UserId: null), TestContext.Current.CancellationToken);
 
         Assert.Equal(ErrorType.Unauthorized, result.FirstError.Type);
     }
@@ -93,7 +92,7 @@ public sealed class GetTrackStreamQueryHandlerTests : HandlerTestBase
 
         var handler = CreateHandler(TestConfigurations.Playback(allowAnonymousListening: true));
 
-        var result = await handler.Handle(new GetTrackStreamQuery(track.Id, UserId: null), TestContext.Current.CancellationToken);
+        var result = await handler.Handle(new StartListeningCommand(track.Id, UserId: null), TestContext.Current.CancellationToken);
 
         Assert.False(result.IsError);
         Assert.Equal("ticket-token", result.Value.Ticket);

web-player/src/lib/api/schema.d.ts

@@ -142,6 +142,23 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/albums/{id}/tracks": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** Add Your Uploaded Tracks To An Album, Skipping The Ones It Already Has. */
+        post: operations["AddAlbumTracks"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/albums/{albumId}/tracks/{trackId}": {
         parameters: {
             query?: never;
@@ -151,8 +168,7 @@ export interface paths {
         };
         get?: never;
         put?: never;
-        /** Add One Of Your Uploaded Tracks To An Album. */
+        post?: never;
-        post: operations["AddTrackToAlbum"];
         /** Remove A Track From An Album. */
         delete: operations["RemoveTrackFromAlbum"];
         options?: never;
@@ -323,8 +339,7 @@ export interface paths {
         /** Get Paginated Tracks Of A PlayList. */
         get: operations["GetPlayListTracks"];
         put?: never;
-        /** Add One Of Your Tracks To A PlayList. */
+        post?: never;
-        post: operations["AddPlayListTrack"];
         delete?: never;
         options?: never;
         head?: never;
@@ -400,6 +415,23 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/playlists/{id}/tracks": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** Add Tracks To A PlayList, Skipping The Ones It Already Has. */
+        post: operations["AddPlayListTracks"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/playlists/{playlistId}/tracks/{trackId}": {
         parameters: {
             query?: never;
@@ -729,9 +761,8 @@ export interface paths {
 export type webhooks = Record<string, never>;
 export interface components {
     schemas: {
-        AddPlayListTrackRequest: {
+        AddTracksRequest: {
-            /** Format: uuid */
+            trackIds: string[];
-            trackId: string;
         };
         AlbumApplicationResponse: {
             /** Format: uuid */
@@ -810,8 +841,7 @@ export interface components {
         MixApplicationResponse: {
             /** Format: uuid */
             id: string;
-            title: string;
+            kind: components["schemas"]["MixKind"];
-            subtitle: null | string;
             /** Format: int32 */
             itemCount: number | string;
             items: components["schemas"]["MixItemApplicationResponse"][];
@@ -826,6 +856,8 @@ export interface components {
             /** Format: int32 */
             listensCount: number | string;
         };
+        /** @enum {unknown} */
+        MixKind: "Discovery" | "Daily";
         PaginatedResponseOfAlbumApplicationResponse: {
             items: components["schemas"]["AlbumApplicationResponse"][];
             /** Format: int32 */
@@ -1157,7 +1189,7 @@ export interface operations {
             };
             header?: never;
             path: {
-                userId: number | string;
+                userId: unknown;
             };
             cookie?: never;
         };
@@ -1415,17 +1447,20 @@ export interface operations {
             };
         };
     };
-    AddTrackToAlbum: {
+    AddAlbumTracks: {
         parameters: {
             query?: never;
             header?: never;
             path: {
-                albumId: string;
+                id: string;
-                trackId: string;
             };
             cookie?: never;
         };
-        requestBody?: never;
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["AddTracksRequest"];
+            };
+        };
         responses: {
             /** @description No Content */
             204: {
@@ -1434,6 +1469,15 @@ export interface operations {
                 };
                 content?: never;
             };
+            /** @description Bad Request */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/problem+json": components["schemas"]["HttpValidationProblemDetails"];
+                };
+            };
             /** @description Unauthorized */
             401: {
                 headers: {
@@ -1735,7 +1779,7 @@ export interface operations {
             };
             header?: never;
             path: {
-                userId: number | string;
+                userId: unknown;
             };
             cookie?: never;
         };
@@ -1784,60 +1828,6 @@ export interface operations {
             };
         };
     };
-    AddPlayListTrack: {
-        parameters: {
-            query?: never;
-            header?: never;
-            path: {
-                playlistId: string;
-            };
-            cookie?: never;
-        };
-        requestBody: {
-            content: {
-                "application/json": components["schemas"]["AddPlayListTrackRequest"];
-            };
-        };
-        responses: {
-            /** @description Created */
-            201: {
-                headers: {
-                    [name: string]: unknown;
-                };
-                content: {
-                    "application/json": components["schemas"]["TrackApplicationResponse"];
-                };
-            };
-            /** @description Unauthorized */
-            401: {
-                headers: {
-                    [name: string]: unknown;
-                };
-                content?: never;
-            };
-            /** @description Forbidden */
-            403: {
-                headers: {
-                    [name: string]: unknown;
-                };
-                content?: never;
-            };
-            /** @description Not Found */
-            404: {
-                headers: {
-                    [name: string]: unknown;
-                };
-                content?: never;
-            };
-            /** @description Conflict */
-            409: {
-                headers: {
-                    [name: string]: unknown;
-                };
-                content?: never;
-            };
-        };
-    };
     GetPlayListCover: {
         parameters: {
             query?: {
@@ -2058,6 +2048,67 @@ export interface operations {
             };
         };
     };
+    AddPlayListTracks: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: string;
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["AddTracksRequest"];
+            };
+        };
+        responses: {
+            /** @description No Content */
+            204: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Bad Request */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/problem+json": components["schemas"]["HttpValidationProblemDetails"];
+                };
+            };
+            /** @description Unauthorized */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Forbidden */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Not Found */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Conflict */
+            409: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
     RemoveTrackFromPlayList: {
         parameters: {
             query?: never;
@@ -2329,7 +2380,7 @@ export interface operations {
             };
             header?: never;
             path: {
-                userId: number | string;
+                userId: unknown;
             };
             cookie?: never;
         };
@@ -2477,7 +2528,7 @@ export interface operations {
             query?: never;
             header?: never;
             path: {
-                id: number | string;
+                id: unknown;
             };
             cookie?: never;
         };
@@ -2506,7 +2557,7 @@ export interface operations {
             query?: never;
             header?: never;
             path: {
-                id: number | string;
+                id: unknown;
             };
             cookie?: never;
         };
@@ -2535,7 +2586,7 @@ export interface operations {
             query?: never;
             header?: never;
             path: {
-                id: number | string;
+                id: unknown;
             };
             cookie?: never;
         };
@@ -2571,7 +2622,7 @@ export interface operations {
             query?: never;
             header?: never;
             path: {
-                id: number | string;
+                id: unknown;
             };
             cookie?: never;
         };
@@ -2600,7 +2651,7 @@ export interface operations {
             query?: never;
             header?: never;
             path: {
-                id: number | string;
+                id: unknown;
             };
             cookie?: never;
         };
@@ -2632,7 +2683,7 @@ export interface operations {
             };
             header?: never;
             path: {
-                id: number | string;
+                id: unknown;
             };
             cookie?: never;
         };
@@ -2671,7 +2722,7 @@ export interface operations {
             };
             header?: never;
             path: {
-                id: number | string;
+                id: unknown;
             };
             cookie?: never;
         };
@@ -2700,7 +2751,7 @@ export interface operations {
             query?: never;
             header?: never;
             path: {
-                id: number | string;
+                id: unknown;
             };
             cookie?: never;
         };
@@ -2729,7 +2780,7 @@ export interface operations {
             query?: never;
             header?: never;
             path: {
-                id: number | string;
+                id: unknown;
             };
             cookie?: never;
         };
@@ -2772,7 +2823,7 @@ export interface operations {
             query?: never;
             header?: never;
             path: {
-                id: number | string;
+                id: unknown;
             };
             cookie?: never;
         };

web-player/src/lib/data/mixes.ts

@@ -4,6 +4,21 @@ import type { ApiTrackLike } from '$lib/player/player.svelte';
 export type Mix = components['schemas']['MixApplicationResponse'];
 export type MixItem = components['schemas']['MixItemApplicationResponse'];
 
+const MIX_TEXTS: Record<Mix['kind'], { title: string; subtitle: string }> = {
+	Discovery: {
+		title: 'Descubrimiento',
+		subtitle: 'Canciones de tu biblioteca que todavía no has escuchado.'
+	},
+	Daily: {
+		title: 'Tu mezcla diaria',
+		subtitle: 'Lo que más escuchas, con alguna sorpresa de tu biblioteca.'
+	}
+};
+
+export function mixText(mix: Pick<Mix, 'kind'>): { title: string; subtitle: string } {
+	return MIX_TEXTS[mix.kind];
+}
+
 export function mixItemKey(item: MixItem): string {
 	return `mf:${item.trackId}`;
 }

web-player/src/lib/server/playlistActions.ts

@@ -15,15 +15,12 @@ export async function addTrackAction({ request, params, locals, fetch }: Request
 	}
 
 	const api = createApiClient({ fetch, accessToken });
-	const { error: err, response } = await api.POST('/playlists/{playlistId}/tracks', {
+	const { error: err } = await api.POST('/playlists/{id}/tracks', {
-		params: { path: { playlistId } },
+		params: { path: { id: playlistId } },
-		body: { trackId }
+		body: { trackIds: [trackId] }
 	});
 
 	if (err) {
-		if (response?.status === 409) {
-			return fail(409, { message: 'La canción ya está en esa playlist.', trackId });
-		}
 		return fail(502, { message: 'No se pudo añadir la canción.', trackId });
 	}
 
@@ -51,14 +48,18 @@ export async function addAlbumToPlaylistAction({ request, params, locals, fetch
 		return fail(502, { message: 'No se pudo cargar el álbum.', albumId });
 	}
 
-	let added = 0;
+	const trackIds = tracks.items.map((track) => String(track.id));
-	for (const track of tracks.items) {
+	if (trackIds.length === 0) {
-		const { error: err } = await api.POST('/playlists/{playlistId}/tracks', {
+		return { addedAlbum: true, albumId, playlistId, added: 0 };
-			params: { path: { playlistId } },
-			body: { trackId: String(track.id) }
-		});
-		if (!err) added++;
 	}
 
-	return { addedAlbum: true, albumId, playlistId, added };
+	const { error: addErr } = await api.POST('/playlists/{id}/tracks', {
+		params: { path: { id: playlistId } },
+		body: { trackIds }
+	});
+	if (addErr) {
+		return fail(502, { message: 'No se pudo añadir el álbum.', albumId });
+	}
+
+	return { addedAlbum: true, albumId, playlistId, added: trackIds.length };
 }

web-player/src/routes/(app)/albums/[id]/+page.server.ts

@@ -54,8 +54,9 @@ export const actions: Actions = {
 		if (!trackId) return fail(400, { message: 'Falta la canción.' });
 
 		const api = createApiClient({ fetch, accessToken });
-		const result = await api.POST('/albums/{albumId}/tracks/{trackId}', {
+		const result = await api.POST('/albums/{id}/tracks', {
-			params: { path: { albumId: params.id, trackId } }
+			params: { path: { id: params.id } },
+			body: { trackIds: [trackId] }
 		});
 		const failure = unwrapOrFail(result, 'No se pudo añadir la canción.');
 		if (failure) return failure;

web-player/src/routes/(app)/mixes/[id]/+page.svelte

@@ -18,11 +18,12 @@
 	import ContextMenu from '$lib/components/ui/overlay/ContextMenu.svelte';
 	import ListPlus from '@lucide/svelte/icons/list-plus';
 	import { createTrackMenu } from '$lib/state/menus.svelte';
-	import { mixItemTrack } from '$lib/data/mixes';
+	import { mixItemTrack, mixText } from '$lib/data/mixes';
 
 	let { data, form } = $props();
 
 	const mix = $derived(data.mix);
+	const text = $derived(mixText(mix));
 	const items = $derived(mix.items);
 	const tracks = $derived(items.map(mixItemTrack));
 	const queue = $derived(tracks.map(toQueueItem));
@@ -49,8 +50,8 @@
 </script>
 
 <svelte:head>
-	<title>{mix.title}</title>
+	<title>{text.title}</title>
-	<meta name="description" content="Mezcla {mix.title}, hecha para ti." />
+	<meta name="description" content="Mezcla {text.title}, hecha para ti." />
 </svelte:head>
 
 <Page>
@@ -58,15 +59,15 @@
 
 	<PageHeader
 		eyebrow="Mezcla"
-		title={mix.title}
+		title={text.title}
-		description={mix.subtitle ?? undefined}
+		description={text.subtitle}
 		meta="{plural(items.length, 'canción', 'canciones')} · {fmtTime(totalSeconds)}"
 	>
 		{#snippet cover()}
 			<Artwork
 				trackIds={items.map((item) => item.trackId)}
 				size="hero"
-				alt={mix.title}
+				alt={text.title}
 				class="shrink-0"
 			/>
 		{/snippet}

web-player/src/routes/+page.svelte

@@ -14,7 +14,7 @@
 	} from '$lib/player/player.svelte';
 	import { pressable } from '$lib/actions/pressable';
 	import { mergeRecentlyPlayed } from '$lib/data/recentlyPlayed';
-	import { mixItemTrack } from '$lib/data/mixes';
+	import { mixItemTrack, mixText } from '$lib/data/mixes';
 	import { fmtTime, fmtDurationLong, fmtPlays, plural } from '$lib/utils/format';
 	import Page from '$lib/components/ui/layout/Page.svelte';
 	import Artwork from '$lib/components/ui/media/Artwork.svelte';
@@ -279,8 +279,8 @@
 					{#each mixes as mix, i (mix.id)}
 						<MediaCard
 							href="/mixes/{mix.id}"
-							title={mix.title}
+							title={mixText(mix).title}
-							subtitle={mix.subtitle}
+							subtitle={mixText(mix).subtitle}
 							trackIds={mix.items.map((item) => item.trackId)}
 							onPlay={(event) => playMix(mix, event)}
 							index={i}