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

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

backend/.editorconfig

@@ -0,0 +1,79 @@
+root = true
+
+[*]
+charset = utf-8
+insert_final_newline = true
+trim_trailing_whitespace = true
+indent_style = space
+
+[*.{csproj,props,targets,slnx,xml}]
+indent_size = 2
+
+[*.json]
+indent_size = 4
+
+[**/Migrations/**.cs]
+generated_code = true
+
+[*.cs]
+indent_size = 4
+
+csharp_style_namespace_declarations = block_scoped:warning
+csharp_using_directive_placement = outside_namespace:warning
+dotnet_sort_system_directives_first = true
+dotnet_separate_import_directive_groups = false
+dotnet_diagnostic.IDE0005.severity = warning
+
+dotnet_style_require_accessibility_modifiers = always:warning
+csharp_style_var_for_built_in_types = true:suggestion
+csharp_style_var_when_type_is_apparent = true:suggestion
+csharp_style_var_elsewhere = true:suggestion
+csharp_prefer_braces = when_multiline:warning
+csharp_style_prefer_primary_constructors = true:suggestion
+csharp_style_expression_bodied_methods = when_on_single_line:suggestion
+dotnet_style_prefer_collection_expression = when_types_loosely_match:suggestion
+
+# Naming. Roslyn applies the first matching rule in file order, so the specific rules come first.
+# Private fields are _camelCase whatever their modifiers (static, readonly, const).
+dotnet_naming_rule.private_fields.symbols = private_fields
+dotnet_naming_rule.private_fields.style = underscore_camel_case
+dotnet_naming_rule.private_fields.severity = warning
+dotnet_naming_symbols.private_fields.applicable_kinds = field
+dotnet_naming_symbols.private_fields.applicable_accessibilities = private
+dotnet_naming_style.underscore_camel_case.capitalization = camel_case
+dotnet_naming_style.underscore_camel_case.required_prefix = _
+
+# Non-private fields (constants, static readonly, etc.) are PascalCase.
+dotnet_naming_rule.other_fields.symbols = other_fields
+dotnet_naming_rule.other_fields.style = pascal_case
+dotnet_naming_rule.other_fields.severity = warning
+dotnet_naming_symbols.other_fields.applicable_kinds = field
+dotnet_naming_symbols.other_fields.applicable_accessibilities = public, internal, protected, protected_internal, private_protected
+dotnet_naming_style.pascal_case.capitalization = pascal_case
+
+dotnet_naming_rule.interfaces.symbols = interfaces
+dotnet_naming_rule.interfaces.style = interface_style
+dotnet_naming_rule.interfaces.severity = warning
+dotnet_naming_symbols.interfaces.applicable_kinds = interface
+dotnet_naming_style.interface_style.capitalization = pascal_case
+dotnet_naming_style.interface_style.required_prefix = I
+
+dotnet_naming_rule.types_and_members.symbols = types_and_members
+dotnet_naming_rule.types_and_members.style = pascal_case
+dotnet_naming_rule.types_and_members.severity = warning
+dotnet_naming_symbols.types_and_members.applicable_kinds = class, struct, enum, delegate, property, method, event
+dotnet_naming_symbols.types_and_members.applicable_accessibilities = *
+
+# CA1848/CA1873 would turn every log call into a [LoggerMessage] source-generated method; CA1716 flags the
+# EF-style IDatabase.Set<T>() and the Musify.Application.Shared namespace, whose names are deliberate.
+dotnet_diagnostic.CA1848.severity = suggestion
+dotnet_diagnostic.CA1873.severity = suggestion
+dotnet_diagnostic.CA1716.severity = suggestion
+# The routing slip builders are stateless services resolved from DI; they stay instance members.
+dotnet_diagnostic.CA1822.severity = suggestion
+
+# Test names follow Method_Scenario_Expected.
+[Tests/**.cs]
+dotnet_diagnostic.CA1707.severity = none
+# xUnit collection fixtures are conventionally named ...Collection.
+dotnet_diagnostic.CA1711.severity = none

backend/CLAUDE.md

@@ -0,0 +1,58 @@
+# Musify: backend
+
+.NET 10 solution (`Musify.slnx`): `Core/` (Domain, Application, Infrastructure), `Hosts/` (Api, Worker, StreamingGateway) and `Tests/`. Architecture and flows are in `../docs/`.
+
+## Commands
+
+Run from `backend/`.
+
+```sh
+dotnet build Musify.slnx            # warnings are errors, including unused usings (IDE0005)
+dotnet test Musify.slnx             # Infrastructure and Api tests need Docker (Testcontainers)
+dotnet format Musify.slnx --verify-no-changes
+```
+
+- Read the totals of `dotnet test` (`total:`, `succeeded:`) before trusting it; don't chain it with `&&` into a commit.
+- EF migrations: `dotnet ef migrations add <Name> --project Core/Musify.Infrastructure --startup-project Core/Musify.Infrastructure` (set `Database__ConnectionString` to any value). A model change needs a migration; the entity model lives in `ModelConfiguration.Apply`, which the in-memory test database reuses.
+- An HTTP contract change (routes, DTOs, responses) needs the web-player schema regenerated (`web-player/src/lib/api/schema.d.ts`, from `/openapi/v1.json`) and `npm run check` clean.
+- A MassTransit message change (events, routing slip arguments, process kinds) means the queues must be drained before deploying; note it in the commit.
+
+## Style
+
+- Block-scoped namespaces (`namespace X { }`; file-scoped `namespace X;` is not allowed), usings outside the namespace and sorted (`.editorconfig` enforces it).
+- Private fields are `_camelCase` whatever their modifiers (including `static readonly` and `const`); non-private constants and static fields, types, methods and properties are PascalCase; interfaces start with `I`; explicit accessibility. Enforced by `.editorconfig` (IDE1006).
+- `ArgumentNullException.ThrowIfNull(x)` without `nameof`.
+- Use `PlayList` (not `Playlist`) in code; configuration POCOs end in `Configuration`; injected services are named after their type (`storageService`).
+- User-facing strings are in English (the web-player owns translation).
+- Trim stored names; normalized columns go through `TextNormalizer.Normalize`.
+- Format ids and numbers with `CultureInfo.InvariantCulture`; put `CancellationToken` last.
+
+## Application layer
+
+- One file per use case, `<Feature>/<UseCase>.cs`, holding the record and its handler; responses go in `Responses/`.
+- Errors come from `AppErrors` (`NotFound`, `Forbidden` = 403 for "not the owner", `Conflict`). `Error.Unauthorized` (401) only means "not signed in". The success value is `Result.Success`; the API maps it to 204.
+- Handlers that cannot fail return plain types. Lists are paginated through `PageRequest` / `ToPaginatedAsync`, ordered with an `Id` tiebreak, and public reads return only `LifeCycleStatus.Active` rows.
+- Owned-entity operations go through `FindOwnedAsync` (non-active entities are not found).
+- No try/catch around `SaveChangesAsync` or `PublishAsync` in handlers: the outbox makes publish + save atomic. Infrastructure either handles an error or lets it propagate; never log and rethrow.
+- List query records keep `int PageNumber, int PageSize`; the API binds them through `PageQuery` and validates them with `PageQueryValidator`.
+
+## API layer
+
+- Routes: `{id:guid}` for the resource, `{trackId:guid}` for sub-resources, `{id:long}` / `{userId:long}` for user ids.
+- Every endpoint returns `IResult` (`Results.Ok` when the handler cannot fail, `ToHttpResult()` otherwise).
+- Validation limits live in `Validators/Limits.cs`; the database column length wins when a limit disagrees with the web-player. Upload allow-lists are in `Validators/Uploads.cs`.
+- `.WithSummary(...)` is sentence case without a trailing period.
+
+## Infrastructure and hosts
+
+- MassTransit routing slips are built from `RoutingSlips.Create` / `AddStep` / `TrackFaults`; activities for the three owner types share generic bases (`MarkLifeCycleActivity<T>`, `DeleteEntityActivity<T>`, `UpdatePicturesActivity<T>`).
+- Recurring work is Hangfire (`RecurringJobsRegistrar`); intervals are in seconds and rounded up to whole minutes.
+- The Worker calls `AddApplication` and validates its service container on build, so any handler dependency must be registered there. Shared config sections in its `appsettings.json` mirror the API's.
+- The StreamingGateway references neither Application nor Infrastructure and keeps its own options.
+
+## Tests
+
+- xUnit v3; pass `TestContext.Current.CancellationToken` to methods that take a token (analyzer xUnit1051).
+- Test names are `Method_Scenario_Expected`.
+- Application tests use the in-memory SQLite `TestDatabase`; Infrastructure and Api tests use Testcontainers (Postgres, SeaweedFS). MassTransit sagas and consumers are tested on the MassTransit test harness.
+- `Infrastructure` exposes its internals to `Musify.Infrastructure.Tests`.

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

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

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

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

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

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

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

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

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

@@ -3,6 +3,7 @@ using Mediator;
 using Microsoft.EntityFrameworkCore;
 using Musify.Application.Albums.Responses;
 using Musify.Application.Contracts;
+using Musify.Application.Shared;
 
 namespace Musify.Application.Albums
 {
@@ -16,23 +17,14 @@ namespace Musify.Application.Albums
         {
             var album = await database.Albums
                 .AsNoTracking()
+                .Active()
                 .Where(a => a.Id == request.Id)
-                .Select(a => new
-                {
-                    Album = a,
-                    TrackCount = a.AlbumTracks.Count,
-                    CoverTrackIds = a.AlbumTracks
-                        .OrderBy(albumTrack => albumTrack.TrackNumber)
-                        .Take(AlbumApplicationResponse.CoverTrackCount)
-                        .Select(albumTrack => albumTrack.TrackId)
-                        .ToList()
-                })
+                .SelectResponse()
                 .SingleOrDefaultAsync(cancellationToken);
 
-            if (album == null)
-                return Error.NotFound();
-
-            return AlbumApplicationResponse.FromEntity(album.Album, album.TrackCount, album.CoverTrackIds);
+            return album == null
+                ? AppErrors.NotFound("Album", request.Id)
+                : album;
         }
     }
 }

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

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

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

@@ -1,11 +1,10 @@
 using ErrorOr;
 using Mediator;
 using Microsoft.EntityFrameworkCore;
+using Musify.Application.Albums.Responses;
 using Musify.Application.Contracts;
 using Musify.Application.Shared;
 using Musify.Application.Tracks.Responses;
-using X.PagedList;
-using X.PagedList.EF;
 
 namespace Musify.Application.Albums
 {
@@ -22,28 +21,19 @@ namespace Musify.Application.Albums
         {
             var albumExists = await database.Albums
                 .AsNoTracking()
+                .Active()
                 .AnyAsync(album => album.Id == request.AlbumId, cancellationToken);
             if (!albumExists)
-                return Error.NotFound();
+                return AppErrors.NotFound("Album", request.AlbumId);
 
-            var tracksQuery = database.AlbumHasTracks
+            return await database.AlbumHasTracks
                 .AsNoTracking()
-                .Include(albumTrack => albumTrack.Track.Owner)
-                .Include(albumTrack => albumTrack.Track.Tags)
-                .Where(albumTrack => albumTrack.AlbumId == request.AlbumId);
-
-            var totalCount = await tracksQuery.CountAsync(cancellationToken);
-
-            var pagedEntities = await tracksQuery
+                .Where(albumTrack => albumTrack.AlbumId == request.AlbumId && albumTrack.Track.LifeCycleStatus == Domain.ValueObjects.LifeCycleStatus.Active)
                 .OrderBy(albumTrack => albumTrack.TrackNumber)
-                .Select(albumTrack => new { albumTrack.Track, ListensCount = albumTrack.Track.ListeningHistories.Count(l => l.IsCounted) })
-                .ToPagedListAsync(request.PageNumber, request.PageSize, totalCount, cancellationToken);
-
-            var pagedTracks = new StaticPagedList<TrackApplicationResponse>(
-                pagedEntities.Select(entry => TrackApplicationResponse.FromEntity(entry.Track, entry.ListensCount)),
-                pagedEntities.PageNumber, pagedEntities.PageSize, pagedEntities.TotalItemCount);
-
-            return PaginatedResponse<TrackApplicationResponse>.FromPagedList(pagedTracks);
+                .ThenBy(albumTrack => albumTrack.Id)
+                .Select(albumTrack => albumTrack.Track)
+                .SelectResponse()
+                .ToPaginatedAsync(new PageRequest(request.PageNumber, request.PageSize), cancellationToken);
         }
     }
 }

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

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

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

@@ -4,8 +4,6 @@ using Microsoft.EntityFrameworkCore;
 using Musify.Application.Albums.Responses;
 using Musify.Application.Contracts;
 using Musify.Application.Shared;
-using X.PagedList;
-using X.PagedList.EF;
 
 namespace Musify.Application.Albums
 {
@@ -21,33 +19,16 @@ namespace Musify.Application.Albums
                 .AsNoTracking()
                 .AnyAsync(user => user.Id == request.UserId, cancellationToken);
             if (!userExists)
-                return Error.NotFound(description: $"User {request.UserId} not found");
+                return AppErrors.NotFound("User", request.UserId);
 
-            var albumsQuery = database.Albums
+            return await database.Albums
                 .AsNoTracking()
-                .Where(album => album.OwnerUserId == request.UserId);
-
-            var totalCount = await albumsQuery.CountAsync(cancellationToken);
-
-            var pagedEntities = await albumsQuery
+                .Active()
+                .Where(album => album.OwnerUserId == request.UserId)
                 .OrderByDescending(album => album.CreatedAt)
-                .Select(album => new
-                {
-                    Album = album,
-                    TrackCount = album.AlbumTracks.Count,
-                    CoverTrackIds = album.AlbumTracks
-                        .OrderBy(albumTrack => albumTrack.TrackNumber)
-                        .Take(AlbumApplicationResponse.CoverTrackCount)
-                        .Select(albumTrack => albumTrack.TrackId)
-                        .ToList()
-                })
-                .ToPagedListAsync(request.PageNumber, request.PageSize, totalCount, cancellationToken);
-
-            var pagedAlbums = new StaticPagedList<AlbumApplicationResponse>(
-                pagedEntities.Select(entry => AlbumApplicationResponse.FromEntity(entry.Album, entry.TrackCount, entry.CoverTrackIds)),
-                pagedEntities.PageNumber, pagedEntities.PageSize, pagedEntities.TotalItemCount);
-
-            return PaginatedResponse<AlbumApplicationResponse>.FromPagedList(pagedAlbums);
+                .ThenBy(album => album.Id)
+                .SelectResponse()
+                .ToPaginatedAsync(new PageRequest(request.PageNumber, request.PageSize), cancellationToken);
         }
     }
 }

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

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

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

@@ -3,6 +3,7 @@ using Mediator;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.Logging;
 using Musify.Application.Contracts;
+using Musify.Application.Shared;
 
 namespace Musify.Application.Albums
 {
@@ -16,20 +17,9 @@ namespace Musify.Application.Albums
     {
         public async ValueTask<ErrorOr<Success>> Handle(RemoveTrackFromAlbumCommand request, CancellationToken cancellationToken)
         {
-            var album = await database.Albums
-                .AsNoTracking()
-                .SingleOrDefaultAsync(a => a.Id == request.AlbumId, cancellationToken);
-            if (album == null)
-            {
-                logger.LogInformation("Album {AlbumId} not found", request.AlbumId);
-                return Error.NotFound();
-            }
-
-            if (album.OwnerUserId != request.UserId)
-            {
-                logger.LogWarning("User {UserId} is not the owner of album {AlbumId}", request.UserId, request.AlbumId);
-                return Error.Unauthorized();
-            }
+            var album = await database.Albums.FindOwnedAsync(request.AlbumId, request.UserId, cancellationToken);
+            if (album.IsError)
+                return album.Errors;
 
             var albumTracks = await database.AlbumHasTracks
                 .Where(albumTrack => albumTrack.AlbumId == request.AlbumId)
@@ -38,10 +28,7 @@ namespace Musify.Application.Albums
 
             var link = albumTracks.SingleOrDefault(albumTrack => albumTrack.TrackId == request.TrackId);
             if (link == null)
-            {
-                logger.LogInformation("Track {TrackId} not in album {AlbumId}", request.TrackId, request.AlbumId);
-                return Error.NotFound(description: "Track is not in the album.");
-            }
+                return Error.NotFound("Album.TrackNotFound", "Track is not in the album.");
 
             database.AlbumHasTracks.Remove(link);
 
@@ -53,7 +40,7 @@ namespace Musify.Application.Albums
 
             logger.LogInformation("Removed track {TrackId} from album {AlbumId}", request.TrackId, request.AlbumId);
 
-            return new Success();
+            return Result.Success;
         }
     }
 }

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

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

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

@@ -1,6 +1,4 @@
-using System.Text.Json.Serialization;
 using Musify.Domain.Entities;
-using Musify.Application.Serialization;
 
 namespace Musify.Application.Albums.Responses
 {
@@ -9,7 +7,7 @@ namespace Musify.Application.Albums.Responses
         string Title,
         string? Description,
         int? ReleaseYear,
-        [property: JsonConverter(typeof(LongAsStringConverter))] long OwnerUserId,
+        long OwnerUserId,
         int TrackCount,
         string? SmallImageKeyName,
         string? MediumImageKeyName,
@@ -18,7 +16,7 @@ namespace Musify.Application.Albums.Responses
         DateTime UpdatedAt,
         IReadOnlyList<Guid> CoverTrackIds)
     {
-        public const int CoverTrackCount = 4;
+        public const int CoverTrackCount = AlbumProjections.CoverTrackCount;
 
         public static AlbumApplicationResponse FromEntity(
             Album album,

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

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

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

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

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

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

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

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

backend/Core/Musify.Application/Application.csproj

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

backend/Core/Musify.Application/ApplicationDependencyInjection.cs

@@ -3,25 +3,27 @@ using Microsoft.Extensions.DependencyInjection;
 using Musify.Application.Configuration;
 using Musify.Application.Services;
 
-namespace Musify.Application;
-
-public static class ApplicationDependencyInjection
+namespace Musify.Application
 {
+    public static class ApplicationDependencyInjection
+    {
         public static IServiceCollection AddApplication(this IServiceCollection services, IConfiguration configuration)
         {
             services.AddMediator();
             services.AddScoped<UploadIntentValidator>();
+            services.AddScoped<UploadIntentIssuer>();
             services.AddScoped<TrackStreamIssuer>();
 
-        services.AddValidatedOptions<ApplicationStorageConfiguration>(configuration, ApplicationStorageConfiguration.SectionName);
-        services.AddValidatedOptions<PlayListConfiguration>(configuration, PlayListConfiguration.SectionName);
-        services.AddValidatedOptions<AlbumConfiguration>(configuration, AlbumConfiguration.SectionName);
-        services.AddValidatedOptions<TrackConfiguration>(configuration, TrackConfiguration.SectionName);
-        services.AddValidatedOptions<MixConfiguration>(configuration, MixConfiguration.SectionName);
-        services.AddValidatedOptions<StreamGatewayConfiguration>(configuration, StreamGatewayConfiguration.SectionName);
-        services.AddValidatedOptions<UploadIntentConfiguration>(configuration, UploadIntentConfiguration.SectionName);
-        services.AddValidatedOptions<PlaybackConfiguration>(configuration, PlaybackConfiguration.SectionName);
+            services.AddValidatedOptions<ApplicationStorageConfiguration>(configuration);
+            services.AddValidatedOptions<PlayListConfiguration>(configuration);
+            services.AddValidatedOptions<AlbumConfiguration>(configuration);
+            services.AddValidatedOptions<TrackConfiguration>(configuration);
+            services.AddValidatedOptions<MixConfiguration>(configuration);
+            services.AddValidatedOptions<StreamGatewayConfiguration>(configuration);
+            services.AddValidatedOptions<UploadIntentConfiguration>(configuration);
+            services.AddValidatedOptions<PlaybackConfiguration>(configuration);
 
             return services;
         }
+    }
 }

backend/Core/Musify.Application/AssemblyInfo.cs

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

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

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

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

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

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

@@ -2,10 +2,14 @@ using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Options;
 
-namespace Musify.Application.Configuration;
-
-public static class ConfigurationDependencyInjection
+namespace Musify.Application.Configuration
 {
+    public static class ConfigurationDependencyInjection
+    {
+        public static IServiceCollection AddValidatedOptions<T>(this IServiceCollection services, IConfiguration configuration)
+            where T : class, IConfigurationOptions =>
+            services.AddValidatedOptions<T>(configuration, T.SectionName);
+
         public static IServiceCollection AddValidatedOptions<T>(
             this IServiceCollection services,
             IConfiguration configuration,
@@ -22,4 +26,5 @@ public static class ConfigurationDependencyInjection
 
             return services;
         }
+    }
 }

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

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

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

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

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

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

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

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

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

@@ -3,9 +3,9 @@ using System.ComponentModel.DataAnnotations;
 namespace Musify.Application.Configuration
 {
 
-    public sealed class PlaybackConfiguration
+    public sealed class PlaybackConfiguration : IConfigurationOptions
     {
-        public const string SectionName = "Playback";
+        public static string SectionName => "Playback";
 
         public bool AllowAnonymousListening { get; set; }
 

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

@@ -2,9 +2,9 @@ using System.ComponentModel.DataAnnotations;
 
 namespace Musify.Application.Configuration
 {
-    public class StreamGatewayConfiguration
+    public class StreamGatewayConfiguration : IConfigurationOptions
     {
-        public const string SectionName = "StreamGateway";
+        public static string SectionName => "StreamGateway";
 
         [Url]
         [Required]

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

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

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

@@ -2,9 +2,9 @@ using System.ComponentModel.DataAnnotations;
 
 namespace Musify.Application.Configuration
 {
-    public class UploadIntentConfiguration
+    public class UploadIntentConfiguration : IConfigurationOptions
     {
-        public const string SectionName = "UploadIntent";
+        public static string SectionName => "UploadIntent";
 
         [Range(10, 3600)]
         public int UploadUrlExpiresInSeconds { get; set; } = 120;
@@ -31,12 +31,12 @@ namespace Musify.Application.Configuration
         public int ExpiredIntentsRetentionDays { get; set; } = 7;
 
         [Required, MinLength(1)]
-        public string TemporalRootPrefix { get; set; } = "temporal";
+        public string TempRootPrefix { get; set; } = "temp";
 
         [Range(1, 30)]
-        public int TemporalUploadsRetentionDays { get; set; } = 3;
+        public int TempUploadsRetentionDays { get; set; } = 3;
 
         [Range(60, 86400)]
-        public int TemporalCleanUpJobIntervalSeconds { get; set; } = 3600;
+        public int TempCleanupJobIntervalSeconds { get; set; } = 3600;
     }
 }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -8,7 +8,5 @@ namespace Musify.Application.Events
         string Bucket,
         string PictureSourceKey,
         string PictureDestinationKey,
-        ImageSize Small,
-        ImageSize Medium,
-        ImageSize Large);
+        ImageSizes Sizes);
 }

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

@@ -8,7 +8,5 @@ namespace Musify.Application.Events
         string Bucket,
         string PictureSourceKey,
         string PictureDestinationKey,
-        ImageSize Small,
-        ImageSize Medium,
-        ImageSize Large);
+        ImageSizes Sizes);
 }

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

@@ -12,7 +12,5 @@ namespace Musify.Application.Events
         string AudioSourceKey,
         string AudioDestinationKey,
         string AudioProcessedFolderKey,
-        ImageSize Small,
-        ImageSize Medium,
-        ImageSize Large);
+        ImageSizes Sizes);
 }

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

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

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

@@ -6,7 +6,5 @@ namespace Musify.Application.Events
         Guid AlbumId,
         string Bucket,
         string SourceKey,
-        ImageSize Small,
-        ImageSize Medium,
-        ImageSize Large);
+        ImageSizes Sizes);
 }

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

@@ -8,7 +8,5 @@ namespace Musify.Application.Events
         string Bucket,
         string PictureSourceKey,
         string PictureDestinationKey,
-        ImageSize Small,
-        ImageSize Medium,
-        ImageSize Large);
+        ImageSizes Sizes);
 }

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

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

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

@@ -8,7 +8,5 @@ namespace Musify.Application.Events
         string Bucket,
         string PictureSourceKey,
         string PictureDestinationKey,
-        ImageSize Small,
-        ImageSize Medium,
-        ImageSize Large);
+        ImageSizes Sizes);
 }

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

@@ -1,4 +1,4 @@
-namespace Musify.Application.Events
+namespace Musify.Application.Events
 {
     public record UpdateTrackAudioEvent(
         Guid TrackId,

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

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

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

@@ -1,12 +1,11 @@
 using Mediator;
+using Musify.Application.Genres.Responses;
 using Musify.Domain.ValueObjects;
 
 namespace Musify.Application.Genres
 {
     public record GetAvailableGenresQuery : IQuery<IReadOnlyList<AvailableGenreResponse>>;
 
-    public record AvailableGenreResponse(Genre Genre, IReadOnlyList<Genre> IncompatibleWith);
-
     public class GetAvailableGenresQueryHandler
         : IQueryHandler<GetAvailableGenresQuery, IReadOnlyList<AvailableGenreResponse>>
     {

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

@@ -1,14 +1,13 @@
 using Mediator;
 using Microsoft.EntityFrameworkCore;
 using Musify.Application.Contracts;
+using Musify.Application.Genres.Responses;
 using Musify.Domain.ValueObjects;
 
 namespace Musify.Application.Genres
 {
     public record GetGenresQuery : IQuery<IReadOnlyList<GenreResponse>>;
 
-    public record GenreResponse(Genre Genre, int TrackCount);
-
     public class GetGenresQueryHandler(IDatabase database)
         : IQueryHandler<GetGenresQuery, IReadOnlyList<GenreResponse>>
     {
@@ -16,7 +15,7 @@ namespace Musify.Application.Genres
         {
             var rows = await database.TrackTags
                 .AsNoTracking()
-                .Where(tag => database.UserHasTracks.Any(userTrack => userTrack.TrackId == tag.TrackId))
+                .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/Genres/Responses/AvailableGenreResponse.cs

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

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

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

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

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

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

@@ -3,7 +3,9 @@ using Mediator;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.Logging;
 using Musify.Application.Contracts;
+using Musify.Application.Shared;
 using Musify.Domain.Entities;
+using Musify.Domain.ValueObjects;
 
 namespace Musify.Application.Likes
 {
@@ -19,12 +21,9 @@ namespace Musify.Application.Likes
         {
             var trackExists = await database.Tracks
                 .AsNoTracking()
-                .AnyAsync(t => t.Id == request.TrackId, cancellationToken);
+                .AnyAsync(t => t.Id == request.TrackId && t.LifeCycleStatus == LifeCycleStatus.Active, cancellationToken);
             if (!trackExists)
-            {
-                logger.LogInformation("Track {TrackId} not found", request.TrackId);
-                return Error.NotFound(description: $"Track {request.TrackId} not found");
-            }
+                return AppErrors.NotFound("Track", request.TrackId);
 
             var existingLike = await database.TrackLikes
                 .SingleOrDefaultAsync(like => like.UserId == request.UserId && like.TrackId == request.TrackId, cancellationToken);
@@ -45,7 +44,11 @@ namespace Musify.Application.Likes
                 nowLiked = true;
             }
 
-            await database.SaveChangesAsync(cancellationToken);
+            // A concurrent double click can hit the unique index; the outcome is already in place, so treat it as a no-op.
+            var saved = await database.TrySaveChangesAsync(
+                AppErrors.Conflict("TrackLike.Duplicate", "Track is already liked."), cancellationToken);
+            if (saved.IsError)
+                return true;
 
             logger.LogInformation("User {UserId} {Action} track {TrackId}",
                 request.UserId, nowLiked ? "liked" : "unliked", request.TrackId);

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

@@ -1,4 +1,3 @@
-using ErrorOr;
 using Mediator;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.Logging;
@@ -10,30 +9,30 @@ using Musify.Domain.ValueObjects;
 namespace Musify.Application.Mixes
 {
     public record GenerateMixesForUserCommand(long UserId)
-        : ICommand<ErrorOr<Success>>;
+        : ICommand;
 
     public class GenerateMixesForUserCommandHandler(
         IDatabase database,
         MixConfiguration mixConfiguration,
         ILogger<GenerateMixesForUserCommandHandler> logger)
-        : ICommandHandler<GenerateMixesForUserCommand, ErrorOr<Success>>
+        : ICommandHandler<GenerateMixesForUserCommand>
     {
-        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)
+        public async ValueTask<Unit> 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)
-                .Select(userTrack => userTrack.TrackId)
+                .Where(track => track.OwnerUserId == userId && track.LifeCycleStatus == LifeCycleStatus.Active)
+                .Select(track => track.Id)
                 .ToListAsync(cancellationToken);
 
             if (libraryTrackIds.Count == 0)
             {
                 logger.LogInformation("User {UserId} has no tracks yet, skipping mix generation", userId);
-                return new Success();
+                return Unit.Value;
             }
 
             var historyTrackIds = await database.ListeningHistories
@@ -51,41 +50,27 @@ namespace Musify.Application.Mixes
             var discovery = Take(Shuffle(unheardTrackIds));
             if (discovery.Count > 0)
             {
-                drafts.Add(new MixDraft(
-                    "Descubrimiento",
-                    "Canciones de tu biblioteca que todavía no has escuchado.",
-                    discovery));
+                drafts.Add(new MixDraft(MixKind.Discovery, discovery));
             }
 
             var daily = Take(Interleave(Shuffle(historyTrackIds), Shuffle(unheardTrackIds)));
             if (daily.Count > 0)
             {
-                drafts.Add(new MixDraft(
-                    "Tu mezcla diaria",
-                    "Lo que más escuchas, con alguna sorpresa de tu biblioteca.",
-                    daily));
+                drafts.Add(new MixDraft(MixKind.Daily, daily));
             }
 
             if (drafts.Count == 0)
             {
                 logger.LogInformation("No candidate songs found for user {UserId}, skipping mix generation", userId);
-                return new Success();
+                return Unit.Value;
             }
 
             await ReplaceMixesAsync(userId, drafts, cancellationToken);
 
-            try
-            {
             await database.SaveChangesAsync(cancellationToken);
-            }
-            catch (Exception exception)
-            {
-                logger.LogError(exception, "Failed to generate mixes for user {UserId}", userId);
-                return Error.Failure(description: $"Failed to generate mixes for user {userId}");
-            }
 
             logger.LogInformation("Generated {Count} mixes for user {UserId}", drafts.Count, userId);
-            return new Success();
+            return Unit.Value;
         }
 
         private List<Guid> Take(IEnumerable<Guid> trackIds) =>
@@ -94,7 +79,7 @@ namespace Musify.Application.Mixes
         private static List<Guid> Shuffle(IEnumerable<Guid> trackIds) =>
             [.. trackIds.OrderBy(_ => Guid.NewGuid())];
 
-        private static List<Guid> Interleave(IReadOnlyList<Guid> first, IReadOnlyList<Guid> second)
+        private static List<Guid> Interleave(List<Guid> first, List<Guid> second)
         {
             var merged = new List<Guid>(first.Count + second.Count);
             for (var index = 0; index < Math.Max(first.Count, second.Count); index++)
@@ -116,12 +101,6 @@ namespace Musify.Application.Mixes
 
             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);
             }
 
@@ -131,8 +110,7 @@ namespace Musify.Application.Mixes
                 var mix = new Mix
                 {
                     UserId = userId,
-                    Title = draft.Title,
-                    Subtitle = draft.Subtitle,
+                    Kind = draft.Kind,
                     Position = position
                 };
 

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

@@ -3,6 +3,7 @@ using Mediator;
 using Microsoft.EntityFrameworkCore;
 using Musify.Application.Contracts;
 using Musify.Application.Mixes.Responses;
+using Musify.Application.Shared;
 
 namespace Musify.Application.Mixes
 {
@@ -20,12 +21,12 @@ namespace Musify.Application.Mixes
                 .SingleOrDefaultAsync(mix => mix.Id == request.MixId && mix.UserId == request.UserId, cancellationToken);
 
             if (mix == null)
-                return Error.NotFound(description: $"Mix {request.MixId} was not found");
+                return AppErrors.NotFound("Mix", request.MixId);
 
             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

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

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

@@ -2,6 +2,7 @@ using Microsoft.EntityFrameworkCore;
 using Musify.Application.Contracts;
 using Musify.Application.Mixes.Responses;
 using Musify.Domain.Entities;
+using Musify.Domain.ValueObjects;
 
 namespace Musify.Application.Mixes
 {
@@ -18,7 +19,7 @@ namespace Musify.Application.Mixes
             var tracksById = await database.Tracks
                 .AsNoTracking()
                 .Include(track => track.Owner)
-                .Where(track => trackIds.Contains(track.Id))
+                .Where(track => trackIds.Contains(track.Id) && track.LifeCycleStatus == LifeCycleStatus.Active)
                 .Select(track => new { Track = track, ListensCount = track.ListeningHistories.Count(l => l.IsCounted) })
                 .ToDictionaryAsync(x => x.Track.Id, cancellationToken);
 

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,
-        string? Subtitle,
+        MixKind Kind,
         int ItemCount,
         IReadOnlyList<MixItemApplicationResponse> Items)
     {

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

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

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

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

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

@@ -1,6 +1,6 @@
-namespace Musify.Application.Albums.Responses
+namespace Musify.Application.Pictures.Responses
 {
-    public record AlbumPictureUploadResponse(
+    public record PictureUploadResponse(
         Guid IntentId,
         string Bucket,
         string Key,

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -1,37 +0,0 @@
-using System.Globalization;
-using System.Text.Json;
-using System.Text.Json.Serialization;
-
-namespace Musify.Application.Serialization;
-
-public sealed class LongAsStringConverter : JsonConverter<long>
-{
-    public override long Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options) =>
-        reader.TokenType == JsonTokenType.String
-            ? long.Parse(reader.GetString()!, CultureInfo.InvariantCulture)
-            : reader.GetInt64();
-
-    public override void Write(Utf8JsonWriter writer, long value, JsonSerializerOptions options) =>
-        writer.WriteStringValue(value.ToString(CultureInfo.InvariantCulture));
-}
-
-public sealed class NullableLongAsStringConverter : JsonConverter<long?>
-{
-    public override long? Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
-    {
-        if (reader.TokenType == JsonTokenType.Null)
-            return null;
-
-        return reader.TokenType == JsonTokenType.String
-            ? string.IsNullOrEmpty(reader.GetString()) ? null : long.Parse(reader.GetString()!, CultureInfo.InvariantCulture)
-            : reader.GetInt64();
-    }
-
-    public override void Write(Utf8JsonWriter writer, long? value, JsonSerializerOptions options)
-    {
-        if (value.HasValue)
-            writer.WriteStringValue(value.Value.ToString(CultureInfo.InvariantCulture));
-        else
-            writer.WriteNullValue();
-    }
-}

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;
-
-public sealed class TrackStreamIssuer(
-    IDatabase database,
+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(
         IStreamTicketService ticketService,
         TrackConfiguration trackConfiguration,
         StreamGatewayConfiguration streamGatewayConfiguration,
         PlaybackConfiguration playbackConfiguration)
-{
-    public async Task<TrackStreamResponse> IssueAsync(
-        Guid trackId,
-        string audioFolderName,
-        long? userId,
-        CancellationToken cancellationToken)
+    {
+        public TrackStreamResponse Issue(string audioFolderName, long? userId, Guid? listenId)
         {
             var folderPath = trackConfiguration.Routes.BuildProcessedAudioPath(audioFolderName);
-        var keyPrefix = $"{folderPath}/";
-
-        var maxBytes = AnonymousFragmentBytes(userId);
-        var ticket = ticketService.IssueTicket(userId, keyPrefix, maxBytes);
+            var ticket = ticketService.IssueTicket(userId, $"{folderPath}/", AnonymousFragmentBytes(userId));
 
             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);
         }
 
@@ -53,4 +32,5 @@ public sealed class TrackStreamIssuer(
 
             return (long)playbackConfiguration.AnonymousFragmentSeconds * playbackConfiguration.EstimatedAudioBytesPerSecond;
         }
+    }
 }

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

@@ -0,0 +1,134 @@
+using ErrorOr;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Logging;
+using Musify.Application.Configuration;
+using Musify.Application.Contracts;
+using Musify.Application.Pictures.Responses;
+using Musify.Application.Shared;
+using Musify.Domain.Entities;
+using Musify.Domain.ValueObjects;
+
+namespace Musify.Application.Services
+{
+    public sealed record UploadRequest(
+        UploadIntentPurpose Purpose,
+        PictureRoutes Routes,
+        string FileType,
+        string ContentType,
+        long? ExpectedSizeBytes);
+
+    public sealed record IssuedUpload(
+        Guid IntentId,
+        string Key,
+        string ObjectName,
+        string ContentType,
+        string UploadUrl);
+
+    /// <summary>Issues pre-signed upload URLs and the upload intents that track them, checking the user quota first.</summary>
+    public sealed class UploadIntentIssuer(
+        IDatabase database,
+        IStorageService storageService,
+        UploadIntentValidator uploadIntentValidator,
+        ApplicationStorageConfiguration storageConfiguration,
+        UploadIntentConfiguration uploadIntentConfiguration,
+        ILogger<UploadIntentIssuer> logger)
+    {
+        public async Task<ErrorOr<IReadOnlyList<IssuedUpload>>> IssueAsync(
+            long userId,
+            IReadOnlyList<UploadRequest> requests,
+            CancellationToken cancellationToken)
+        {
+            var userExists = await database.Users
+                .AsNoTracking()
+                .AnyAsync(user => user.Id == userId, cancellationToken);
+            if (!userExists)
+                return AppErrors.NotFound("User", userId);
+
+            var planned = requests
+                .Select(request =>
+                {
+                    var objectName = $"{Guid.NewGuid()}.{request.FileType.TrimStart('.').ToLowerInvariant()}";
+                    var key = request.Routes.BuildTempPath(uploadIntentConfiguration.TempRootPrefix, userId, objectName);
+                    var size = request.ExpectedSizeBytes ?? DefaultSize(request.Purpose);
+                    return (Request: request, ObjectName: objectName, Key: key, Size: size);
+                })
+                .ToList();
+
+            await using var transaction = await database.BeginTransactionAsync(
+                System.Data.IsolationLevel.Serializable, cancellationToken);
+
+            var quota = await uploadIntentValidator.CheckQuotaAsync(
+                userId, planned.Sum(item => item.Size), planned.Count, cancellationToken);
+            if (quota.IsError)
+                return quota.Errors;
+
+            var expiresIn = TimeSpan.FromSeconds(uploadIntentConfiguration.UploadUrlExpiresInSeconds);
+            var expiresAt = DateTime.UtcNow + expiresIn;
+            var issued = new List<IssuedUpload>(planned.Count);
+
+            foreach (var item in planned)
+            {
+                var uploadUrl = await storageService.GetUploadUrlAsync(
+                    storageConfiguration.Bucket, item.Key, item.Request.ContentType, expiresIn, cancellationToken: cancellationToken);
+
+                var intent = new UploadIntent
+                {
+                    UserId = userId,
+                    Bucket = storageConfiguration.Bucket,
+                    Key = item.Key,
+                    ObjectName = item.ObjectName,
+                    ContentType = item.Request.ContentType,
+                    ExpectedSizeBytes = item.Size,
+                    Purpose = item.Request.Purpose,
+                    ExpiresAt = expiresAt,
+                };
+
+                await database.UploadIntents.AddAsync(intent, cancellationToken);
+                issued.Add(new IssuedUpload(intent.Id, item.Key, item.ObjectName, item.Request.ContentType, uploadUrl));
+            }
+
+            await database.SaveChangesAsync(cancellationToken);
+            await transaction.CommitAsync(cancellationToken);
+
+            logger.LogInformation("Issued {Count} upload intents for user {UserId} ({Purposes})",
+                issued.Count, userId, string.Join('/', planned.Select(item => item.Request.Purpose)));
+
+            return issued;
+        }
+
+        public async Task<ErrorOr<IssuedUpload>> IssueOneAsync(long userId, UploadRequest request, CancellationToken cancellationToken)
+        {
+            var issued = await IssueAsync(userId, [request], cancellationToken);
+            return issued.IsError ? issued.Errors : issued.Value[0];
+        }
+
+        public async Task<ErrorOr<PictureUploadResponse>> IssuePictureAsync(
+            long userId,
+            UploadIntentPurpose purpose,
+            IPictureOwnerConfiguration owner,
+            string fileType,
+            string contentType,
+            long? expectedSizeBytes,
+            CancellationToken cancellationToken)
+        {
+            var issued = await IssueOneAsync(
+                userId, new UploadRequest(purpose, owner.Routes, fileType, contentType, expectedSizeBytes), cancellationToken);
+            if (issued.IsError)
+                return issued.Errors;
+
+            return new PictureUploadResponse(
+                issued.Value.IntentId,
+                storageConfiguration.Bucket,
+                issued.Value.Key,
+                issued.Value.ObjectName,
+                issued.Value.ContentType,
+                uploadIntentConfiguration.UploadUrlExpiresInSeconds,
+                issued.Value.UploadUrl);
+        }
+
+        private long DefaultSize(UploadIntentPurpose purpose) =>
+            purpose == UploadIntentPurpose.TrackAudio
+                ? uploadIntentConfiguration.DefaultExpectedAudioSizeBytes
+                : uploadIntentConfiguration.DefaultExpectedPictureSizeBytes;
+    }
+}

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

@@ -1,63 +1,78 @@
 using ErrorOr;
 using Microsoft.EntityFrameworkCore;
 using Musify.Application.Configuration;
+using Musify.Application.Contracts;
+using Musify.Application.Shared;
 using Musify.Domain.Entities;
 using Musify.Domain.ValueObjects;
-using Musify.Application.Contracts;
 
-namespace Musify.Application.Services;
-
-public sealed class UploadIntentValidator(
-    IDatabase database,
-    IStorageService storageService)
+namespace Musify.Application.Services
 {
+    public sealed class UploadIntentValidator(
+        IDatabase database,
+        IStorageService storageService,
+        UploadIntentConfiguration config)
+    {
         public async Task<ErrorOr<Success>> CheckQuotaAsync(
-        UploadIntentConfiguration config,
             long userId,
             long requiredBytes,
             int requiredIntentCount,
             CancellationToken cancellationToken)
         {
-        var activeIntents = await database.UploadIntents
-            .AsNoTracking()
-            .Where(i => i.UserId == userId && i.Status == UploadIntentStatus.Issued)
-            .ToListAsync(cancellationToken);
+            var now = DateTime.UtcNow;
+            var pictureDefault = config.DefaultExpectedPictureSizeBytes;
+            var audioDefault = config.DefaultExpectedAudioSizeBytes;
 
-        if (activeIntents.Count + requiredIntentCount > config.MaxActiveUploadIntentsPerUser)
+            var active = await database.UploadIntents
+                .AsNoTracking()
+                .Where(intent => intent.UserId == userId && intent.Status == UploadIntentStatus.Issued && intent.ExpiresAt > now)
+                .GroupBy(_ => 1)
+                .Select(group => new
+                {
+                    Count = group.Count(),
+                    Bytes = group.Sum(intent => intent.ExpectedSizeBytes
+                        ?? (intent.Purpose == UploadIntentPurpose.TrackAudio ? audioDefault : pictureDefault))
+                })
+                .SingleOrDefaultAsync(cancellationToken);
+
+            if ((active?.Count ?? 0) + requiredIntentCount > config.MaxActiveUploadIntentsPerUser)
                 return Error.Validation(description: "Upload intent limit exceeded. Wait for existing uploads to complete or expire.");
 
-        var activeBytes = activeIntents.Sum(i => i.ExpectedSizeBytes ?? config.DefaultExpectedPictureSizeBytes);
-        if (activeBytes + requiredBytes > config.MaxActiveUploadBytesPerUser)
+            if ((active?.Bytes ?? 0) + requiredBytes > config.MaxActiveUploadBytesPerUser)
                 return Error.Validation(description: "Upload byte quota exceeded. Wait for existing uploads to complete or expire.");
 
-        return new Success();
+            return Result.Success;
         }
 
         public async Task<ErrorOr<UploadIntent>> ValidateAndLoadAsync(
-        UploadIntentConfiguration config,
             Guid intentId,
             long userId,
+            UploadIntentPurpose purpose,
             CancellationToken cancellationToken)
         {
             var intent = await database.UploadIntents
                 .FirstOrDefaultAsync(i => i.Id == intentId, cancellationToken);
 
             if (intent == null || intent.UserId != userId)
-            return Error.NotFound(description: "Upload intent not found or not accessible.");
+                return AppErrors.NotFound("UploadIntent", intentId);
+
+            if (intent.Purpose != purpose)
+                return Error.Validation(description: "Upload intent was issued for a different purpose.");
 
             if (intent.IsConsumed)
-            return Error.Conflict(description: "Upload intent has already been consumed.");
+                return AppErrors.Conflict("UploadIntent.Consumed", "Upload intent has already been consumed.");
 
-        if (intent.IsExpired)
+            if (intent.IsExpiredAt(DateTime.UtcNow))
                 return Error.Validation(description: "Upload intent has expired.");
 
             var metadata = await storageService.HeadObjectAsync(intent.Bucket, intent.Key, cancellationToken);
             if (metadata == null)
-            return Error.NotFound(description: "Uploaded object not found in storage. Upload the file first.");
+                return Error.NotFound("UploadIntent.ObjectMissing", "Uploaded object not found in storage. Upload the file first.");
 
             if (metadata.ContentLength > config.MaxUploadBytes)
                 return Error.Validation(description: $"Uploaded file exceeds the maximum allowed size of {config.MaxUploadBytes} bytes.");
 
             return intent;
         }
+    }
 }

backend/Core/Musify.Application/Shared/AppErrors.cs

@@ -0,0 +1,16 @@
+using ErrorOr;
+
+namespace Musify.Application.Shared
+{
+    public static class AppErrors
+    {
+        public static Error NotFound(string entity, object id) =>
+            Error.NotFound($"{entity}.NotFound", $"{entity} {id} was not found.");
+
+        public static Error Forbidden(string entity, object id) =>
+            Error.Forbidden($"{entity}.Forbidden", $"You do not have permission to modify {entity} {id}.");
+
+        public static Error Conflict(string code, string description) =>
+            Error.Conflict(code, description);
+    }
+}

backend/Core/Musify.Application/Shared/ImageSize.cs

@@ -1,7 +1,12 @@
-namespace Musify.Application.Shared
+namespace Musify.Application.Shared
 {
     public record ImageSize(
         string SavePath,
         int Width,
         int Height);
+
+    public record ImageSizes(
+        ImageSize Small,
+        ImageSize Medium,
+        ImageSize Large);
 }

backend/Core/Musify.Application/Shared/OwnershipExtensions.cs

@@ -0,0 +1,29 @@
+using ErrorOr;
+using Microsoft.EntityFrameworkCore;
+using Musify.Domain.Abstractions;
+using Musify.Domain.ValueObjects;
+
+namespace Musify.Application.Shared
+{
+    public static class OwnershipExtensions
+    {
+        /// <summary>
+        /// Loads an active, tracked entity owned by <paramref name="userId"/>: NotFound when it is missing
+        /// or not active, Forbidden when someone else owns it.
+        /// </summary>
+        public static async Task<ErrorOr<T>> FindOwnedAsync<T>(
+            this DbSet<T> set, Guid id, long userId, CancellationToken cancellationToken)
+            where T : class, IOwnedEntity, IHasLifeCycle
+        {
+            var entity = await set.SingleOrDefaultAsync(
+                e => e.Id == id && e.LifeCycleStatus == LifeCycleStatus.Active, cancellationToken);
+
+            if (entity == null)
+                return AppErrors.NotFound(typeof(T).Name, id);
+
+            return entity.OwnerUserId == userId
+                ? entity
+                : AppErrors.Forbidden(typeof(T).Name, id);
+        }
+    }
+}

backend/Core/Musify.Application/Shared/PaginatedResponse.cs

@@ -1,26 +0,0 @@
-using X.PagedList;
-
-namespace Musify.Application.Shared
-{
-    public record PaginatedResponse<T>(
-        IReadOnlyCollection<T> Items,
-        int PageNumber,
-        int PageSize,
-        int PageCount,
-        int TotalItemCount,
-        bool HasNextPage,
-        bool HasPreviousPage)
-    {
-        public static PaginatedResponse<T> FromPagedList(IPagedList<T> pagedList)
-        {
-            return new PaginatedResponse<T>(
-                pagedList.ToArray(),
-                pagedList.PageNumber,
-                pagedList.PageSize,
-                pagedList.PageCount,
-                pagedList.TotalItemCount,
-                pagedList.HasNextPage,
-                pagedList.HasPreviousPage);
-        }
-    }
-}

backend/Core/Musify.Application/Shared/Pagination.cs

@@ -0,0 +1,46 @@
+using Microsoft.EntityFrameworkCore;
+
+namespace Musify.Application.Shared
+{
+    public record PageRequest(int PageNumber = 1, int PageSize = 20)
+    {
+        public const int MaxPageSize = 100;
+    }
+
+    public record PaginatedResponse<T>(
+        IReadOnlyList<T> Items,
+        int PageNumber,
+        int PageSize,
+        int PageCount,
+        int TotalItemCount,
+        bool HasNextPage,
+        bool HasPreviousPage);
+
+    public static class PaginationExtensions
+    {
+        /// <summary>Counts and pages the same (already filtered, ordered and projected) query.</summary>
+        public static async Task<PaginatedResponse<T>> ToPaginatedAsync<T>(
+            this IQueryable<T> query, PageRequest page, CancellationToken cancellationToken)
+        {
+            var pageNumber = Math.Max(page.PageNumber, 1);
+            var pageSize = Math.Clamp(page.PageSize, 1, PageRequest.MaxPageSize);
+
+            var totalCount = await query.CountAsync(cancellationToken);
+            var items = await query
+                .Skip((pageNumber - 1) * pageSize)
+                .Take(pageSize)
+                .ToListAsync(cancellationToken);
+
+            var pageCount = (int)Math.Ceiling(totalCount / (double)pageSize);
+
+            return new PaginatedResponse<T>(
+                items,
+                pageNumber,
+                pageSize,
+                pageCount,
+                totalCount,
+                HasNextPage: pageNumber < pageCount,
+                HasPreviousPage: pageNumber > 1 && pageCount > 0);
+        }
+    }
+}

backend/Core/Musify.Application/Shared/TextNormalizer.cs

@@ -0,0 +1,7 @@
+namespace Musify.Application.Shared
+{
+    public static class TextNormalizer
+    {
+        public static string Normalize(string value) => value.Trim().ToUpperInvariant();
+    }
+}

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

@@ -3,13 +3,13 @@ using Mediator;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.Logging;
 using Musify.Application.Configuration;
-using Musify.Application.Shared;
+using Musify.Application.Contracts;
 using Musify.Application.Events;
-using Musify.Application.Tracks.Responses;
 using Musify.Application.Services;
+using Musify.Application.Shared;
+using Musify.Application.Tracks.Responses;
 using Musify.Domain.Entities;
 using Musify.Domain.ValueObjects;
-using Musify.Application.Contracts;
 
 namespace Musify.Application.Tracks
 {
@@ -27,9 +27,7 @@ namespace Musify.Application.Tracks
         IEventBus eventBus,
         UploadIntentValidator uploadIntentValidator,
         ILogger<CreateTrackCommandHandler> logger,
-        ApplicationStorageConfiguration storageConfiguration,
-        TrackConfiguration trackConfiguration,
-        UploadIntentConfiguration uploadIntentConfiguration)
+        TrackConfiguration trackConfiguration)
         : ICommandHandler<CreateTrackCommand, ErrorOr<TrackApplicationResponse>>
     {
         public async ValueTask<ErrorOr<TrackApplicationResponse>> Handle(CreateTrackCommand request, CancellationToken cancellationToken)
@@ -43,31 +41,17 @@ namespace Musify.Application.Tracks
             }
 
             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.");
 
             var pictureValidation = await uploadIntentValidator.ValidateAndLoadAsync(
-                uploadIntentConfiguration,
-                request.PictureIntentId, request.UserId, cancellationToken);
+                request.PictureIntentId, request.UserId, UploadIntentPurpose.TrackPicture, cancellationToken);
             if (pictureValidation.IsError)
                 return pictureValidation.Errors;
 
             var audioValidation = await uploadIntentValidator.ValidateAndLoadAsync(
-                uploadIntentConfiguration,
-                request.AudioIntentId, request.UserId, cancellationToken);
+                request.AudioIntentId, request.UserId, UploadIntentPurpose.TrackAudio, cancellationToken);
             if (audioValidation.IsError)
                 return audioValidation.Errors;
 
@@ -80,8 +64,8 @@ namespace Musify.Application.Tracks
 
             var trackEntity = new Track
             {
-                Title = request.Title,
-                NormalizedTitle = request.Title.ToUpperInvariant(),
+                Title = request.Title.Trim(),
+                NormalizedTitle = TextNormalizer.Normalize(request.Title),
                 OwnerUserId = user.Id,
                 Owner = user,
                 IsExplicit = request.IsExplicit,
@@ -106,54 +90,23 @@ namespace Musify.Application.Tracks
 
             await database.Tracks.AddAsync(trackEntity, cancellationToken);
 
-            await database.UserHasTracks.AddAsync(new UserHasTrack
-            {
-                UserId = request.UserId,
-                TrackId = trackEntity.Id
-            }, cancellationToken);
 
-            try
-            {
+            var sizes = trackConfiguration.PicturesSizes.ToImageSizes(trackConfiguration.Routes);
             await eventBus.PublishAsync(
                 new CreateTrackResourcesEvent(
                     trackEntity.Id,
                     pictureIntent.Id,
                     audioIntent.Id,
-                        storageConfiguration.Bucket,
+                    pictureIntent.Bucket,
                     pictureIntent.Key,
                     finalPictureKey,
                     audioIntent.Key,
                     finalAudioKey,
                     audioProcessedFolderKey,
-                        new ImageSize(
-                            trackConfiguration.Routes.SmallPicturesPath,
-                            trackConfiguration.PicturesSizes.SmallPictureWidth,
-                            trackConfiguration.PicturesSizes.SmallPictureHeight),
-                        new ImageSize(
-                            trackConfiguration.Routes.MediumPicturesPath,
-                            trackConfiguration.PicturesSizes.MediumPictureWidth,
-                            trackConfiguration.PicturesSizes.MediumPictureHeight),
-                        new ImageSize(
-                            trackConfiguration.Routes.LargePicturesPath,
-                            trackConfiguration.PicturesSizes.LargePictureWidth,
-                            trackConfiguration.PicturesSizes.LargePictureHeight)),
+                    sizes),
                 cancellationToken);
-            }
-            catch (Exception exception)
-            {
-                logger.LogError(exception, "Failed to publish create track event for track {TrackId}", trackEntity.Id);
-                return Error.Failure(description: $"Failed to create track for {request.Title}");
-            }
 
-            try
-            {
             await database.SaveChangesAsync(cancellationToken);
-            }
-            catch (Exception exception)
-            {
-                logger.LogError(exception, "Failed to save track {Title}", request.Title);
-                return Error.Failure(description: $"Failed to create track for {request.Title}");
-            }
 
             return TrackApplicationResponse.FromEntity(trackEntity, listensCount: 0);
         }

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

@@ -1,11 +1,10 @@
 using ErrorOr;
 using Mediator;
-using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.Logging;
-using Musify.Domain.Entities;
-using Musify.Domain.ValueObjects;
-using Musify.Application.Events;
 using Musify.Application.Contracts;
+using Musify.Application.Events;
+using Musify.Application.Shared;
+using Musify.Domain.ValueObjects;
 
 namespace Musify.Application.Tracks
 {
@@ -22,50 +21,22 @@ namespace Musify.Application.Tracks
     {
         public async ValueTask<ErrorOr<Success>> Handle(DeleteTrackCommand request, CancellationToken cancellationToken)
         {
-            var track = await database.Tracks.SingleOrDefaultAsync(t => t.Id == request.TrackId, cancellationToken);
-            if (track == null)
-            {
-                logger.LogInformation("Track {TrackId} not found", request.TrackId);
-                return Error.NotFound();
-            }
-
-            if (track.OwnerUserId != request.UserId)
-            {
-                logger.LogWarning("User {UserId} unauthorized to delete track {TrackId}", request.UserId, request.TrackId);
-                return Error.Unauthorized();
-            }
+            var found = await database.Tracks.FindOwnedAsync(request.TrackId, request.UserId, cancellationToken);
+            if (found.IsError)
+                return found.Errors;
 
+            var track = found.Value;
             if (track.Audio.IsInProgress)
-            {
-                logger.LogWarning("Track {TrackId} is currently being processed and cannot be deleted", request.TrackId);
-                return Error.Conflict(description: "Track is currently being processed and cannot be deleted");
-            }
+                return AppErrors.Conflict("Track.Processing", "Track is currently being processed and cannot be deleted.");
 
             track.LifeCycleStatus = LifeCycleStatus.Removing;
 
-            try
-            {
-                await eventBus.PublishAsync(
-                    new DeleteTrackEvent(track.Id, request.UserId),
-                    cancellationToken);
-            }
-            catch (Exception exception)
-            {
-                logger.LogError(exception, "Failed to publish delete track event for track {TrackId}", request.TrackId);
-                return Error.Failure(description: $"Failed to delete track {request.TrackId}");
-            }
-
-            try
-            {
+            await eventBus.PublishAsync(new DeleteTrackEvent(track.Id, request.UserId), cancellationToken);
             await database.SaveChangesAsync(cancellationToken);
-            }
-            catch (Exception exception)
-            {
-                logger.LogError(exception, "Failed to mark track {TrackId} as processing before deletion", request.TrackId);
-                return Error.Failure(description: $"Failed to delete track {request.TrackId}");
-            }
 
-            return new Success();
+            logger.LogInformation("Marked track {TrackId} as removing", request.TrackId);
+
+            return Result.Success;
         }
     }
 }

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

@@ -1,30 +1,27 @@
-using ErrorOr;
 using Mediator;
 using Microsoft.EntityFrameworkCore;
 using Musify.Application.Contracts;
 using Musify.Application.Tracks.Responses;
+using Musify.Domain.ValueObjects;
 
 namespace Musify.Application.Tracks
 {
-    public record GetLastTrackListenedByUserIdQuery(long UserId) : IQuery<ErrorOr<TrackApplicationResponse>>;
+    public record GetLastTrackListenedByUserIdQuery(long UserId) : IQuery<TrackApplicationResponse?>;
 
     public class GetLastTrackListenedByUserIdQueryHandler(IDatabase database)
-        : IQueryHandler<GetLastTrackListenedByUserIdQuery, ErrorOr<TrackApplicationResponse>>
+        : IQueryHandler<GetLastTrackListenedByUserIdQuery, TrackApplicationResponse?>
     {
-        public async ValueTask<ErrorOr<TrackApplicationResponse>> Handle(GetLastTrackListenedByUserIdQuery query, CancellationToken cancellationToken)
+        public async ValueTask<TrackApplicationResponse?> Handle(GetLastTrackListenedByUserIdQuery query, CancellationToken cancellationToken)
         {
-            var track = await database.ListeningHistories
+            return await database.ListeningHistories
                 .AsNoTracking()
                 .Include(t => t.Track.Owner)
                 .Include(t => t.Track.Tags)
-                .Where(t => t.UserId == query.UserId)
+                .Where(t => t.UserId == query.UserId && t.IsCounted && t.Track.LifeCycleStatus == LifeCycleStatus.Active)
                 .OrderByDescending(t => t.ListenedAt)
+                .ThenBy(t => t.Id)
                 .Select(t => TrackApplicationResponse.FromEntity(t.Track, t.Track.ListeningHistories.Count(l => l.IsCounted)))
                 .FirstOrDefaultAsync(cancellationToken);
-
-            return track == null
-                ? Error.NotFound("Track.NotFound", "No track found for the given user ID.")
-                : track;
         }
     }
 }

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

@@ -1,40 +1,40 @@
-using Mediator;
+using Mediator;
 using Microsoft.EntityFrameworkCore;
 using Musify.Application.Contracts;
 using Musify.Application.Tracks.Responses;
 
 namespace Musify.Application.Tracks
 {
-    public record GetListeningHistoryQuery(long UserId) : IQuery<IEnumerable<TrackApplicationResponse>>;
+    public record GetListeningHistoryQuery(long UserId) : IQuery<IReadOnlyList<TrackApplicationResponse>>;
 
-    public class GetListeningHistoryQueryHandler(
-        IDatabase database)
-        : IQueryHandler<GetListeningHistoryQuery, IEnumerable<TrackApplicationResponse>>
+    public class GetListeningHistoryQueryHandler(IDatabase database)
+        : IQueryHandler<GetListeningHistoryQuery, IReadOnlyList<TrackApplicationResponse>>
     {
         public const int ListSize = 15;
 
-        public async ValueTask<IEnumerable<TrackApplicationResponse>> Handle(GetListeningHistoryQuery query, CancellationToken cancellationToken)
+        public async ValueTask<IReadOnlyList<TrackApplicationResponse>> Handle(GetListeningHistoryQuery query, CancellationToken cancellationToken)
         {
             var recentTrackIds = await database.ListeningHistories
                 .AsNoTracking()
                 .Where(l => l.UserId == query.UserId && l.IsCounted)
                 .GroupBy(l => l.TrackId)
                 .OrderByDescending(g => g.Max(l => l.ListenedAt))
+                .ThenBy(g => g.Key)
                 .Select(g => g.Key)
                 .Take(ListSize)
                 .ToListAsync(cancellationToken);
 
             var tracksById = await database.Tracks
                 .AsNoTracking()
-                .Include(t => t.Owner)
-                .Include(t => t.Tags)
+                .Active()
                 .Where(t => recentTrackIds.Contains(t.Id))
-                .Select(t => new { t.Id, Track = t, ListensCount = t.ListeningHistories.Count(l => l.IsCounted) })
+                .SelectResponse()
                 .ToDictionaryAsync(t => t.Id, cancellationToken);
 
             return recentTrackIds
+                .Where(id => tracksById.ContainsKey(id))
                 .Select(id => tracksById[id])
-                .Select(t => TrackApplicationResponse.FromEntity(t.Track, t.ListensCount));
+                .ToList();
         }
     }
 }

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

@@ -2,6 +2,7 @@ using ErrorOr;
 using Mediator;
 using Microsoft.EntityFrameworkCore;
 using Musify.Application.Contracts;
+using Musify.Application.Shared;
 using Musify.Application.Tracks.Responses;
 
 namespace Musify.Application.Tracks
@@ -14,17 +15,16 @@ namespace Musify.Application.Tracks
     {
         public async ValueTask<ErrorOr<TrackApplicationResponse>> Handle(GetTrackByIdQuery request, CancellationToken cancellationToken)
         {
-            var entity = await database.Tracks.AsNoTracking()
-                .Include(t => t.Owner)
-                .Include(t => t.Tags)
+            var track = await database.Tracks
+                .AsNoTracking()
+                .Active()
                 .Where(t => t.Id == request.TrackId)
-                .Select(t => new { Track = t, ListensCount = t.ListeningHistories.Count(l => l.IsCounted) })
+                .SelectResponse()
                 .SingleOrDefaultAsync(cancellationToken);
 
-            if (entity == null)
-                return Error.NotFound();
-
-            return TrackApplicationResponse.FromEntity(entity.Track, entity.ListensCount);
+            return track == null
+                ? AppErrors.NotFound("Track", request.TrackId)
+                : track;
         }
     }
 }

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

@@ -1,53 +0,0 @@
-using ErrorOr;
-using Mediator;
-using Microsoft.EntityFrameworkCore;
-using Musify.Application.Configuration;
-using Musify.Application.Contracts;
-
-namespace Musify.Application.Tracks
-{
-    public record GetTrackCoverQuery(Guid TrackId, string Size)
-        : IQuery<ErrorOr<TrackCoverLocation>>;
-
-    public record TrackCoverLocation(string Bucket, string Key, string ContentType);
-
-    public class GetTrackCoverQueryHandler(
-        IDatabase database,
-        ApplicationStorageConfiguration storageConfiguration,
-        TrackConfiguration trackConfiguration)
-        : IQueryHandler<GetTrackCoverQuery, ErrorOr<TrackCoverLocation>>
-    {
-        public async ValueTask<ErrorOr<TrackCoverLocation>> Handle(GetTrackCoverQuery request, CancellationToken cancellationToken)
-        {
-            var track = await database.Tracks.AsNoTracking()
-                .Where(t => t.Id == request.TrackId)
-                .Select(t => new { t.Pictures.SmallName, t.Pictures.MediumName, t.Pictures.LargeName })
-                .SingleOrDefaultAsync(cancellationToken);
-
-            if (track == null)
-                return Error.NotFound();
-
-            var routes = trackConfiguration.Routes;
-            var (name, key) = request.Size.ToLowerInvariant() switch
-            {
-                "small" => (track.SmallName, BuildKey(routes.BuildSmallPicturePath, track.SmallName)),
-                "large" => (track.LargeName, BuildKey(routes.BuildLargePicturePath, track.LargeName)),
-                _ => (track.MediumName, BuildKey(routes.BuildMediumPicturePath, track.MediumName))
-            };
-
-            if (string.IsNullOrEmpty(name) || key == null)
-                return Error.NotFound();
-
-            var contentType = name.EndsWith(".webp", StringComparison.OrdinalIgnoreCase)
-                ? "image/webp"
-                : name.EndsWith(".png", StringComparison.OrdinalIgnoreCase)
-                    ? "image/png"
-                    : "image/jpeg";
-
-            return new TrackCoverLocation(storageConfiguration.Bucket, key, contentType);
-        }
-
-        private static string? BuildKey(Func<string, string> builder, string? name)
-            => string.IsNullOrEmpty(name) ? null : builder(name);
-    }
-}

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

@@ -1,49 +0,0 @@
-using ErrorOr;
-using Mediator;
-using Microsoft.EntityFrameworkCore;
-using Microsoft.Extensions.Logging;
-using Musify.Application.Configuration;
-using Musify.Application.Contracts;
-using Musify.Application.Services;
-using Musify.Application.Tracks.Responses;
-
-namespace Musify.Application.Tracks
-{
-
-    public record GetTrackStreamQuery(Guid TrackId, long? UserId)
-        : IQuery<ErrorOr<TrackStreamResponse>>;
-
-    public class GetTrackStreamQueryHandler(
-        IDatabase database,
-        TrackStreamIssuer streamIssuer,
-        PlaybackConfiguration playbackConfiguration,
-        ILogger<GetTrackStreamQueryHandler> logger)
-        : IQueryHandler<GetTrackStreamQuery, ErrorOr<TrackStreamResponse>>
-    {
-        public async ValueTask<ErrorOr<TrackStreamResponse>> Handle(GetTrackStreamQuery 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.");
-
-            var track = await database.Tracks.AsNoTracking()
-                .Where(t => t.Id == request.TrackId)
-                .Select(t => new { t.Id, t.Audio })
-                .SingleOrDefaultAsync(cancellationToken);
-
-            if (track == null)
-                return Error.NotFound();
-
-            if (!track.Audio.IsProcessed)
-            {
-                logger.LogInformation("Stream requested for track {TrackId} but audio is not ready", request.TrackId);
-                return Error.Conflict(description: "Track audio is not available for streaming yet.");
-            }
-
-            var response = await streamIssuer.IssueAsync(track.Id, track.Audio.FolderName, request.UserId, cancellationToken);
-
-            logger.LogInformation("Issued stream ticket for track {TrackId} to user {UserId}", request.TrackId, request.UserId?.ToString() ?? "(anonymous)");
-
-            return response;
-        }
-    }
-}

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

@@ -1,57 +1,38 @@
-using ErrorOr;
 using Mediator;
 using Microsoft.EntityFrameworkCore;
-using Musify.Application.Tracks.Responses;
-using X.PagedList;
-using X.PagedList.EF;
 using Musify.Application.Contracts;
+using Musify.Application.Shared;
+using Musify.Application.Tracks.Responses;
 using Musify.Domain.ValueObjects;
 
 namespace Musify.Application.Tracks
 {
     public record GetTracksQuery(string? Name, int PageNumber, int PageSize, Genre? Genre = null)
-        : IQuery<ErrorOr<TracksSearchResponse>>;
+        : IQuery<PaginatedResponse<TrackApplicationResponse>>;
 
     public class GetTracksQueryHandler(IDatabase database)
-        : IQueryHandler<GetTracksQuery, ErrorOr<TracksSearchResponse>>
+        : IQueryHandler<GetTracksQuery, PaginatedResponse<TrackApplicationResponse>>
     {
-        public async ValueTask<ErrorOr<TracksSearchResponse>> Handle(GetTracksQuery request, CancellationToken cancellationToken)
+        public async ValueTask<PaginatedResponse<TrackApplicationResponse>> Handle(GetTracksQuery request, CancellationToken cancellationToken)
         {
-            var tracksQuery = database.UserHasTracks
+            var tracksQuery = database.Tracks
                 .AsNoTracking()
-                .Include(ut => ut.Track.Owner)
-                .Include(ut => ut.Track.Tags)
-                .AsQueryable();
+                .Active();
 
-            if (!string.IsNullOrEmpty(request.Name))
+            if (!string.IsNullOrWhiteSpace(request.Name))
             {
-                var normalizedName = request.Name.Trim().ToUpperInvariant();
-                tracksQuery = tracksQuery.Where(t => t.Track.NormalizedTitle.Contains(normalizedName));
+                var normalizedName = TextNormalizer.Normalize(request.Name);
+                tracksQuery = tracksQuery.Where(track => track.NormalizedTitle.Contains(normalizedName));
             }
 
             if (request.Genre is { } genre)
-                tracksQuery = tracksQuery.Where(t => t.Track.Tags.Any(tag => tag.Tag == genre));
+                tracksQuery = tracksQuery.Where(track => track.Tags.Any(tag => tag.Tag == genre));
 
-            var totalCount = await tracksQuery.CountAsync(cancellationToken);
-
-            var pagedEntities = await tracksQuery
-                .OrderByDescending(t => t.Track.CreatedAt)
-                .ThenBy(t => t.Id)
-                .Select(t => new { t.Track, ListensCount = t.Track.ListeningHistories.Count(l => l.IsCounted) })
-                .ToPagedListAsync(request.PageNumber, request.PageSize, totalCount, cancellationToken);
-
-            var items = pagedEntities
-                .Select(x => TrackSearchItemResponse.FromTrack(TrackApplicationResponse.FromEntity(x.Track, x.ListensCount)))
-                .ToList();
-
-            return new TracksSearchResponse(
-                items,
-                pagedEntities.PageNumber,
-                pagedEntities.PageSize,
-                pagedEntities.PageCount,
-                pagedEntities.TotalItemCount,
-                pagedEntities.HasPreviousPage,
-                pagedEntities.HasNextPage);
+            return await tracksQuery
+                .OrderByDescending(track => track.CreatedAt)
+                .ThenBy(track => track.Id)
+                .SelectResponse()
+                .ToPaginatedAsync(new PageRequest(request.PageNumber, request.PageSize), cancellationToken);
         }
     }
 }

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

@@ -1,11 +1,9 @@
 using ErrorOr;
 using Mediator;
 using Microsoft.EntityFrameworkCore;
+using Musify.Application.Contracts;
 using Musify.Application.Shared;
 using Musify.Application.Tracks.Responses;
-using X.PagedList;
-using X.PagedList.EF;
-using Musify.Application.Contracts;
 
 namespace Musify.Application.Tracks
 {
@@ -21,33 +19,22 @@ namespace Musify.Application.Tracks
     {
         public async ValueTask<ErrorOr<PaginatedResponse<TrackApplicationResponse>>> Handle(GetTracksByUserIdQuery request, CancellationToken cancellationToken)
         {
-            var pageNumber = request.PageNumber < 1 ? 1 : request.PageNumber;
-            var pageSize = request.PageSize < 1 ? 10 : request.PageSize;
-
-            var tracksQuery = database.UserHasTracks
+            var tracksQuery = database.Tracks
                 .AsNoTracking()
-                .Include(ut => ut.Track.Owner)
-                .Include(ut => ut.Track.Tags)
-                .Where(p => p.UserId == request.UserId);
+                .Active()
+                .Where(track => track.OwnerUserId == request.UserId);
 
-            if (!string.IsNullOrEmpty(request.Name))
+            if (!string.IsNullOrWhiteSpace(request.Name))
             {
-                var normalizedName = request.Name.Trim().ToUpperInvariant();
-                tracksQuery = tracksQuery.Where(t => t.Track.NormalizedTitle.Contains(normalizedName));
+                var normalizedName = TextNormalizer.Normalize(request.Name);
+                tracksQuery = tracksQuery.Where(track => track.NormalizedTitle.Contains(normalizedName));
             }
 
-            var totalCount = await tracksQuery.CountAsync(cancellationToken);
-
-            var pagedEntities = await tracksQuery
-                .OrderBy(t => t.Track.CreatedAt)
-                .Select(t => new { t.Track, ListensCount = t.Track.ListeningHistories.Count(l => l.IsCounted) })
-                .ToPagedListAsync(pageNumber, pageSize, totalCount, cancellationToken);
-
-            var pagedTracks = new StaticPagedList<TrackApplicationResponse>(
-                pagedEntities.Select(x => TrackApplicationResponse.FromEntity(x.Track, x.ListensCount)),
-                pagedEntities.PageNumber, pagedEntities.PageSize, pagedEntities.TotalItemCount);
-
-            return PaginatedResponse<TrackApplicationResponse>.FromPagedList(pagedTracks);
+            return await tracksQuery
+                .OrderByDescending(track => track.CreatedAt)
+                .ThenBy(track => track.Id)
+                .SelectResponse()
+                .ToPaginatedAsync(new PageRequest(request.PageNumber, request.PageSize), cancellationToken);
         }
     }
 }

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

@@ -2,6 +2,7 @@ using ErrorOr;
 using Mediator;
 using Microsoft.EntityFrameworkCore;
 using Musify.Application.Contracts;
+using Musify.Application.Shared;
 
 namespace Musify.Application.Tracks
 {
@@ -16,15 +17,12 @@ namespace Musify.Application.Tracks
     {
         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);
 
             if (listen == null)
-                return Error.NotFound();
+                return AppErrors.NotFound("Listen", request.ListenId);
 
             var now = DateTime.UtcNow;
             var durationCap = listen.Track.DurationSeconds + ListeningRules.DurationToleranceSeconds;