Unify API route parameters, return IResult everywhere, merge picture upload DTOs and centralize validation limits

Guid and long route constraints, id/trackId parameter names, Update*Request without the New prefix,
sentence-case operation summaries, shared security scheme id and a single Limits class.

backend/Hosts/Musify.Api/Authentication/JwtBearerOptionsSetup.cs

@@ -8,27 +8,25 @@ namespace Musify.Api.Authentication;
 public sealed class JwtBearerOptionsSetup(IOptions<AuthenticationConfiguration> options)
     : IConfigureNamedOptions<JwtBearerOptions>
 {
-    private readonly AuthenticationConfiguration _configuration = options.Value;
+    private readonly AuthenticationConfiguration configuration = options.Value;
 
     public void Configure(string? name, JwtBearerOptions options)
     {
         if (name != JwtBearerDefaults.AuthenticationScheme)
-        {
             return;
-        }
 
         Configure(options);
     }
 
     public void Configure(JwtBearerOptions options)
     {
-        options.MetadataAddress = _configuration.MetadataAddress;
+        options.MetadataAddress = configuration.MetadataAddress;
-        options.RequireHttpsMetadata = _configuration.RequireHttpsMetadata;
+        options.RequireHttpsMetadata = configuration.RequireHttpsMetadata;
-        options.Audience = _configuration.AudienceAddress;
+        options.Audience = configuration.AudienceAddress;
         options.TokenValidationParameters = new TokenValidationParameters
         {
-            ValidIssuer = _configuration.IssuerAddress,
+            ValidIssuer = configuration.IssuerAddress,
-            ValidAudience = _configuration.AudienceAddress,
+            ValidAudience = configuration.AudienceAddress,
             RoleClaimType = ClaimTypes.Role,
             NameClaimType = ClaimTypes.Name,
         };

backend/Hosts/Musify.Api/DataTransferObjects/Albums/RequestAlbumPictureUploadRequest.cs

@@ -1,6 +0,0 @@
-namespace Musify.Api.DataTransferObjects.Albums;
-
-public record RequestAlbumPictureUploadRequest(
-    string FileType,
-    string ContentType,
-    long? ExpectedSizeBytes = null);

backend/Hosts/Musify.Api/DataTransferObjects/Albums/UpdateAlbumRequest.cs

@@ -1,7 +1,7 @@
 namespace Musify.Api.DataTransferObjects.Albums;
 
 public record UpdateAlbumRequest(
-    string NewTitle,
+    string Title,
-    string? NewDescription,
+    string? Description,
-    int? NewReleaseYear,
+    int? ReleaseYear,
-    Guid? NewPictureIntentId);
+    Guid? PictureIntentId);

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

@@ -0,0 +1,6 @@
+namespace Musify.Api.DataTransferObjects;
+
+public record PictureUploadRequest(
+    string FileType,
+    string ContentType,
+    long? ExpectedSizeBytes = null);

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

@@ -1,6 +0,0 @@
-namespace Musify.Api.DataTransferObjects.PlayLists;
-
-public record RequestPlayListPictureUploadRequest(
-    string FileType,
-    string ContentType,
-    long? ExpectedSizeBytes = null);

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

@@ -3,7 +3,7 @@ using Musify.Domain.ValueObjects;
 namespace Musify.Api.DataTransferObjects.PlayLists;
 
 public record UpdatePlayListRequest(
-    string? NewName,
+    string? Name,
-    string? NewDescription,
+    string? Description,
-    Guid? NewPictureIntentId,
+    Guid? PictureIntentId,
-    PlayListVisibility? NewVisibility = null);
+    PlayListVisibility? Visibility = null);

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

@@ -4,12 +4,12 @@ using Musify.Api.DataTransferObjects;
 using Musify.Api.DataTransferObjects.Albums;
 using Musify.Api.Extensions;
 using Musify.Api.Filters;
+using Musify.Api.Models;
 using Musify.Application.Albums;
 using Musify.Application.Albums.Responses;
 using Musify.Application.Contracts;
 using Musify.Application.Pictures;
 using Musify.Application.Pictures.Responses;
-using Musify.Api.Models;
 using Musify.Application.Shared;
 using Musify.Application.Tracks.Responses;
 
@@ -27,46 +27,46 @@ public static class AlbumEndpoints
         group.MapGet("/", GetAlbums)
             .AddEndpointFilter<ValidationFilter<PageQuery>>()
             .WithName("GetAlbums")
-            .WithSummary("Get Paginated Albums, Optionally Filtered By Title.")
+            .WithSummary("Get paginated albums, optionally filtered by title")
             .Produces<PaginatedResponse<AlbumApplicationResponse>>();
 
-        group.MapGet("/{id}", GetAlbumById)
+        group.MapGet("/{id:guid}", GetAlbumById)
             .WithName("GetAlbumById")
-            .WithSummary("Get An Album By Id.")
+            .WithSummary("Get an album by id")
             .Produces<AlbumApplicationResponse>()
             .Produces(StatusCodes.Status404NotFound);
 
-        group.MapGet("/users/{userId}", GetAlbumsByUserId)
+        group.MapGet("/users/{userId:long}", GetAlbumsByUserId)
             .AddEndpointFilter<ValidationFilter<PageQuery>>()
             .WithName("GetAlbumsByUserId")
-            .WithSummary("Get Paginated Albums For A User.")
+            .WithSummary("Get paginated albums for a user")
             .Produces<PaginatedResponse<AlbumApplicationResponse>>()
             .Produces(StatusCodes.Status404NotFound);
 
         group.MapGet("/recent", GetRecentlyListenedAlbums)
             .WithName("GetRecentlyListenedAlbums")
-            .WithSummary("Get The Albums The Current User Listened To Most Recently.")
+            .WithSummary("Get the albums the current user listened to most recently")
             .RequireAuthorization()
             .Produces<IReadOnlyList<AlbumApplicationResponse>>()
             .Produces(StatusCodes.Status401Unauthorized);
 
-        group.MapGet("/{albumId}/tracks", GetAlbumTracks)
+        group.MapGet("/{id:guid}/tracks", GetAlbumTracks)
             .AddEndpointFilter<ValidationFilter<PageQuery>>()
             .WithName("GetAlbumTracks")
-            .WithSummary("Get The Tracks Of An Album Ordered By Track Number.")
+            .WithSummary("Get the tracks of an album ordered by track number")
             .Produces<PaginatedResponse<TrackApplicationResponse>>()
             .Produces(StatusCodes.Status404NotFound);
 
-        group.MapGet("/{id}/cover", GetAlbumCover)
+        group.MapGet("/{id:guid}/cover", GetAlbumCover)
             .WithName("GetAlbumCover")
-            .WithSummary("Get An Album Cover Image.")
+            .WithSummary("Get an album cover image")
             .Produces(StatusCodes.Status200OK)
             .Produces(StatusCodes.Status404NotFound);
 
         group.MapPost("/upload-picture", RequestAlbumPictureUpload)
             .WithName("RequestAlbumPictureUpload")
-            .WithSummary("Request A Pre-Signed URL To Upload An Album Picture.")
+            .WithSummary("Request a pre-signed URL to upload an album picture")
-            .AddEndpointFilter<ValidationFilter<RequestAlbumPictureUploadRequest>>()
+            .AddEndpointFilter<ValidationFilter<PictureUploadRequest>>()
             .RequireAuthorization()
             .Produces<PictureUploadResponse>()
             .ProducesValidationProblem()
@@ -75,7 +75,7 @@ public static class AlbumEndpoints
 
         group.MapPost("/", CreateAlbum)
             .WithName("CreateAlbum")
-            .WithSummary("Create A New Album.")
+            .WithSummary("Create a new album")
             .AddEndpointFilter<ValidationFilter<CreateAlbumRequest>>()
             .RequireAuthorization()
             .Produces<AlbumApplicationResponse>(StatusCodes.Status201Created)
@@ -83,9 +83,9 @@ public static class AlbumEndpoints
             .Produces(StatusCodes.Status401Unauthorized)
             .Produces(StatusCodes.Status404NotFound);
 
-        group.MapPut("/{albumId}", UpdateAlbum)
+        group.MapPut("/{id:guid}", UpdateAlbum)
             .WithName("UpdateAlbum")
-            .WithSummary("Update An Album.")
+            .WithSummary("Update an album")
             .AddEndpointFilter<ValidationFilter<UpdateAlbumRequest>>()
             .RequireAuthorization()
             .Produces<AlbumApplicationResponse>()
@@ -94,18 +94,18 @@ public static class AlbumEndpoints
             .Produces(StatusCodes.Status403Forbidden)
             .Produces(StatusCodes.Status404NotFound);
 
-        group.MapDelete("/{albumId}", DeleteAlbum)
+        group.MapDelete("/{id:guid}", DeleteAlbum)
             .WithName("DeleteAlbum")
-            .WithSummary("Delete An Album.")
+            .WithSummary("Delete an album")
             .RequireAuthorization()
             .Produces(StatusCodes.Status204NoContent)
             .Produces(StatusCodes.Status401Unauthorized)
             .Produces(StatusCodes.Status403Forbidden)
             .Produces(StatusCodes.Status404NotFound);
 
-        group.MapPost("/{id}/tracks", AddAlbumTracks)
+        group.MapPost("/{id:guid}/tracks", AddAlbumTracks)
             .WithName("AddAlbumTracks")
-            .WithSummary("Add Your Uploaded Tracks To An Album, Skipping The Ones It Already Has.")
+            .WithSummary("Add your uploaded tracks to an album, skipping the ones it already has")
             .AddEndpointFilter<ValidationFilter<AddTracksRequest>>()
             .RequireAuthorization()
             .Produces(StatusCodes.Status204NoContent)
@@ -115,9 +115,9 @@ public static class AlbumEndpoints
             .Produces(StatusCodes.Status404NotFound)
             .Produces(StatusCodes.Status409Conflict);
 
-        group.MapDelete("/{albumId}/tracks/{trackId}", RemoveTrackFromAlbum)
+        group.MapDelete("/{id:guid}/tracks/{trackId:guid}", RemoveTrackFromAlbum)
             .WithName("RemoveTrackFromAlbum")
-            .WithSummary("Remove A Track From An Album.")
+            .WithSummary("Remove a track from an album")
             .RequireAuthorization()
             .Produces(StatusCodes.Status204NoContent)
             .Produces(StatusCodes.Status401Unauthorized)
@@ -176,11 +176,11 @@ public static class AlbumEndpoints
 
     private static async Task<IResult> GetAlbumTracks(
         IMediator mediator,
-        Guid albumId,
+        Guid id,
         CancellationToken cancellationToken,
         [AsParameters] PageQuery page)
     {
-        var result = await mediator.Send(new GetAlbumTracksQuery(albumId, page.PageNumber, page.PageSize), cancellationToken);
+        var result = await mediator.Send(new GetAlbumTracksQuery(id, page.PageNumber, page.PageSize), cancellationToken);
         return result.ToHttpResult();
     }
 
@@ -198,7 +198,7 @@ public static class AlbumEndpoints
     private static async Task<IResult> RequestAlbumPictureUpload(
         IMediator mediator,
         CurrentUser currentUser,
-        RequestAlbumPictureUploadRequest request,
+        PictureUploadRequest request,
         CancellationToken cancellationToken)
     {
         var result = await mediator.Send(
@@ -224,12 +224,12 @@ public static class AlbumEndpoints
     private static async Task<IResult> UpdateAlbum(
         IMediator mediator,
         CurrentUser currentUser,
-        Guid albumId,
+        Guid id,
         UpdateAlbumRequest request,
         CancellationToken cancellationToken)
     {
         var result = await mediator.Send(
-            new UpdateAlbumCommand(currentUser.RequiredId, albumId, request.NewTitle, request.NewDescription, request.NewReleaseYear, request.NewPictureIntentId),
+            new UpdateAlbumCommand(currentUser.RequiredId, id, request.Title, request.Description, request.ReleaseYear, request.PictureIntentId),
             cancellationToken);
 
         return result.ToHttpResult();
@@ -238,10 +238,10 @@ public static class AlbumEndpoints
     private static async Task<IResult> DeleteAlbum(
         IMediator mediator,
         CurrentUser currentUser,
-        Guid albumId,
+        Guid id,
         CancellationToken cancellationToken)
     {
-        var result = await mediator.Send(new DeleteAlbumCommand(currentUser.RequiredId, albumId), cancellationToken);
+        var result = await mediator.Send(new DeleteAlbumCommand(currentUser.RequiredId, id), cancellationToken);
         return result.ToHttpResult();
     }
 
@@ -262,12 +262,12 @@ public static class AlbumEndpoints
     private static async Task<IResult> RemoveTrackFromAlbum(
         IMediator mediator,
         CurrentUser currentUser,
-        Guid albumId,
+        Guid id,
         Guid trackId,
         CancellationToken cancellationToken)
     {
         var result = await mediator.Send(
-            new RemoveTrackFromAlbumCommand(currentUser.RequiredId, albumId, trackId),
+            new RemoveTrackFromAlbumCommand(currentUser.RequiredId, id, trackId),
             cancellationToken);
 
         return result.ToHttpResult();

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

@@ -13,16 +13,17 @@ public static class ConfigEndpoints
 
         group.MapGet("/playback", GetPlaybackPublicConfig)
             .WithName("GetPlaybackPublicConfig")
-            .WithSummary("Get The Public Playback Configuration (Whether Anonymous Listening Is Allowed). Works Anonymously.")
+            .WithSummary("Get the public playback configuration (whether anonymous listening is allowed). Works anonymously")
             .Produces<PlaybackPublicConfigResponse>();
 
         return app;
     }
 
-    private static async Task<PlaybackPublicConfigResponse> GetPlaybackPublicConfig(
+    private static async Task<IResult> GetPlaybackPublicConfig(
         IMediator mediator,
         CancellationToken cancellationToken)
     {
-        return await mediator.Send(new GetPlaybackPublicConfigQuery(), cancellationToken);
+        var result = await mediator.Send(new GetPlaybackPublicConfigQuery(), cancellationToken);
+        return Results.Ok(result);
     }
 }

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

@@ -13,28 +13,30 @@ public static class GenreEndpoints
 
         group.MapGet("/", GetGenres)
             .WithName("GetGenres")
-            .WithSummary("Get The Genres That Have At Least One Track, Most Populated First. Works Anonymously.")
+            .WithSummary("Get the genres that have at least one track, most populated first. Works anonymously")
             .Produces<IReadOnlyList<GenreResponse>>();
 
         group.MapGet("/available", GetAvailableGenres)
             .WithName("GetAvailableGenres")
-            .WithSummary("Get Every Genre A Track Can Be Tagged With, Including The Genres It Cannot Be Combined With. Works Anonymously.")
+            .WithSummary("Get every genre a track can be tagged with, including the genres it cannot be combined with. Works anonymously")
             .Produces<IReadOnlyList<AvailableGenreResponse>>();
 
         return app;
     }
 
-    private static async Task<IReadOnlyList<AvailableGenreResponse>> GetAvailableGenres(
+    private static async Task<IResult> GetAvailableGenres(
         IMediator mediator,
         CancellationToken cancellationToken)
     {
-        return await mediator.Send(new GetAvailableGenresQuery(), cancellationToken);
+        var result = await mediator.Send(new GetAvailableGenresQuery(), cancellationToken);
+        return Results.Ok(result);
     }
 
-    private static async Task<IReadOnlyList<GenreResponse>> GetGenres(
+    private static async Task<IResult> GetGenres(
         IMediator mediator,
         CancellationToken cancellationToken)
     {
-        return await mediator.Send(new GetGenresQuery(), cancellationToken);
+        var result = await mediator.Send(new GetGenresQuery(), cancellationToken);
+        return Results.Ok(result);
     }
 }

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

@@ -2,11 +2,11 @@ using Mediator;
 using Musify.Api.Authentication;
 using Musify.Api.DataTransferObjects.Likes;
 using Musify.Api.Extensions;
-using Musify.Application.Likes;
+using Musify.Api.Filters;
 using Musify.Api.Models;
+using Musify.Application.Likes;
 using Musify.Application.Shared;
 using Musify.Application.Tracks.Responses;
-using Musify.Api.Filters;
 
 namespace Musify.Api.Endpoints;
 
@@ -21,13 +21,13 @@ public static class LikeEndpoints
         group.MapGet("/", GetLikedTracks)
             .AddEndpointFilter<ValidationFilter<PageQuery>>()
             .WithName("GetLikedTracks")
-            .WithSummary("Get The Current User'S Liked Tracks.")
+            .WithSummary("Get the current user's liked tracks")
             .Produces<PaginatedResponse<TrackApplicationResponse>>()
             .Produces(StatusCodes.Status401Unauthorized);
 
         group.MapPost("/toggle", ToggleTrackLike)
             .WithName("ToggleTrackLike")
-            .WithSummary("Like Or Unlike A Track By Id.")
+            .WithSummary("Like or unlike a track by id")
             .Produces<bool>()
             .Produces(StatusCodes.Status401Unauthorized)
             .Produces(StatusCodes.Status404NotFound);

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

@@ -16,13 +16,13 @@ public static class MixEndpoints
 
         group.MapGet("/", GetMixes)
             .WithName("GetMixes")
-            .WithSummary("Get The Server-Generated Mixes Of The Current User.")
+            .WithSummary("Get the server-generated mixes of the current user")
             .Produces<IReadOnlyList<MixApplicationResponse>>()
             .Produces(StatusCodes.Status401Unauthorized);
 
-        group.MapGet("/{id}", GetMixById)
+        group.MapGet("/{id:guid}", GetMixById)
             .WithName("GetMixById")
-            .WithSummary("Get A Mix With All Of Its Songs.")
+            .WithSummary("Get a mix with all of its songs")
             .Produces<MixApplicationResponse>()
             .Produces(StatusCodes.Status401Unauthorized)
             .Produces(StatusCodes.Status404NotFound);

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

@@ -4,12 +4,12 @@ using Musify.Api.DataTransferObjects;
 using Musify.Api.DataTransferObjects.PlayLists;
 using Musify.Api.Extensions;
 using Musify.Api.Filters;
+using Musify.Api.Models;
 using Musify.Application.Contracts;
 using Musify.Application.Pictures;
 using Musify.Application.Pictures.Responses;
 using Musify.Application.PlayLists;
 using Musify.Application.PlayLists.Responses;
-using Musify.Api.Models;
 using Musify.Application.Shared;
 using Musify.Application.Tracks.Responses;
 
@@ -22,34 +22,34 @@ public static class PlayListEndpoints
         var group = app.MapGroup("/playlists")
             .WithTags("PlayLists");
 
-        group.MapGet("/{id}", GetPlayListById)
+        group.MapGet("/{id:guid}", GetPlayListById)
             .WithName("GetPlayListById")
-            .WithSummary("Get A PlayList By Id.")
+            .WithSummary("Get a playlist by id")
             .Produces<PlayListApplicationResponse>()
             .Produces(StatusCodes.Status404NotFound);
 
-        group.MapGet("/users/{userId}", GetPlayListsByUserId)
+        group.MapGet("/users/{userId:long}", GetPlayListsByUserId)
             .AddEndpointFilter<ValidationFilter<PageQuery>>()
             .WithName("GetPlayListsByUserId")
-            .WithSummary("Get Paginated PlayLists For A User. Private PlayLists Are Only Returned To Their Owner.")
+            .WithSummary("Get paginated playlists for a user. Private playlists are only returned to their owner")
             .Produces<PaginatedResponse<PlayListApplicationResponse>>();
 
-        group.MapGet("/{playlistId}/tracks", GetPlayListTracks)
+        group.MapGet("/{id:guid}/tracks", GetPlayListTracks)
             .AddEndpointFilter<ValidationFilter<PageQuery>>()
             .WithName("GetPlayListTracks")
-            .WithSummary("Get Paginated Tracks Of A PlayList.")
+            .WithSummary("Get paginated tracks of a playlist")
             .Produces<PaginatedResponse<TrackApplicationResponse>>()
             .Produces(StatusCodes.Status404NotFound);
 
-        group.MapGet("/{id}/cover", GetPlayListCover)
+        group.MapGet("/{id:guid}/cover", GetPlayListCover)
             .WithName("GetPlayListCover")
-            .WithSummary("Get A PlayList Cover Image.")
+            .WithSummary("Get a playlist cover image")
             .Produces(StatusCodes.Status200OK)
             .Produces(StatusCodes.Status404NotFound);
 
         group.MapPost("/", CreatePlayList)
             .WithName("CreatePlayList")
-            .WithSummary("Create A New PlayList.")
+            .WithSummary("Create a new playlist")
             .AddEndpointFilter<ValidationFilter<CreatePlayListRequest>>()
             .RequireAuthorization()
             .Produces<PlayListApplicationResponse>(StatusCodes.Status201Created)
@@ -57,9 +57,9 @@ public static class PlayListEndpoints
             .Produces(StatusCodes.Status401Unauthorized)
             .Produces(StatusCodes.Status404NotFound);
 
-        group.MapPut("/{playlistId}", UpdatePlayList)
+        group.MapPut("/{id:guid}", UpdatePlayList)
             .WithName("UpdatePlayList")
-            .WithSummary("Update An Existing PlayList.")
+            .WithSummary("Update an existing playlist")
             .AddEndpointFilter<ValidationFilter<UpdatePlayListRequest>>()
             .RequireAuthorization()
             .Produces<PlayListApplicationResponse>()
@@ -68,9 +68,9 @@ public static class PlayListEndpoints
             .Produces(StatusCodes.Status403Forbidden)
             .Produces(StatusCodes.Status404NotFound);
 
-        group.MapDelete("/{playlistId}", DeletePlayList)
+        group.MapDelete("/{id:guid}", DeletePlayList)
             .WithName("DeletePlayList")
-            .WithSummary("Delete A PlayList.")
+            .WithSummary("Delete a playlist")
             .RequireAuthorization()
             .Produces(StatusCodes.Status204NoContent)
             .Produces(StatusCodes.Status401Unauthorized)
@@ -79,17 +79,17 @@ public static class PlayListEndpoints
 
         group.MapPost("/upload-picture", RequestPlayListPictureUpload)
             .WithName("RequestPlayListPictureUpload")
-            .WithSummary("Request A Pre-Signed URL To Upload A PlayList Picture.")
+            .WithSummary("Request a pre-signed URL to upload a playlist picture")
-            .AddEndpointFilter<ValidationFilter<RequestPlayListPictureUploadRequest>>()
+            .AddEndpointFilter<ValidationFilter<PictureUploadRequest>>()
             .RequireAuthorization()
             .Produces<PictureUploadResponse>()
             .ProducesValidationProblem()
             .Produces(StatusCodes.Status401Unauthorized)
             .Produces(StatusCodes.Status404NotFound);
 
-        group.MapPost("/{id}/tracks", AddPlayListTracks)
+        group.MapPost("/{id:guid}/tracks", AddPlayListTracks)
             .WithName("AddPlayListTracks")
-            .WithSummary("Add Tracks To A PlayList, Skipping The Ones It Already Has.")
+            .WithSummary("Add tracks to a playlist, skipping the ones it already has")
             .AddEndpointFilter<ValidationFilter<AddTracksRequest>>()
             .RequireAuthorization()
             .Produces(StatusCodes.Status204NoContent)
@@ -99,9 +99,9 @@ public static class PlayListEndpoints
             .Produces(StatusCodes.Status404NotFound)
             .Produces(StatusCodes.Status409Conflict);
 
-        group.MapDelete("/{playlistId}/tracks/{trackId}", RemoveTrackFromPlayList)
+        group.MapDelete("/{id:guid}/tracks/{trackId:guid}", RemoveTrackFromPlayList)
             .WithName("RemoveTrackFromPlayList")
-            .WithSummary("Remove A Track From A PlayList.")
+            .WithSummary("Remove a track from a playlist")
             .RequireAuthorization()
             .Produces(StatusCodes.Status204NoContent)
             .Produces(StatusCodes.Status401Unauthorized)
@@ -136,11 +136,11 @@ public static class PlayListEndpoints
     private static async Task<IResult> GetPlayListTracks(
         IMediator mediator,
         CurrentUser currentUser,
-        Guid playlistId,
+        Guid id,
         CancellationToken cancellationToken,
         [AsParameters] PageQuery page)
     {
-        var result = await mediator.Send(new GetPlayListTracksQuery(playlistId, page.PageNumber, page.PageSize, currentUser.Id), cancellationToken);
+        var result = await mediator.Send(new GetPlayListTracksQuery(id, page.PageNumber, page.PageSize, currentUser.Id), cancellationToken);
         return result.ToHttpResult();
     }
 
@@ -171,12 +171,12 @@ public static class PlayListEndpoints
     private static async Task<IResult> UpdatePlayList(
         IMediator mediator,
         CurrentUser currentUser,
-        Guid playlistId,
+        Guid id,
         UpdatePlayListRequest request,
         CancellationToken cancellationToken)
     {
         var result = await mediator.Send(
-            new UpdatePlayListCommand(currentUser.RequiredId, playlistId, request.NewName, request.NewDescription, request.NewPictureIntentId, request.NewVisibility),
+            new UpdatePlayListCommand(currentUser.RequiredId, id, request.Name, request.Description, request.PictureIntentId, request.Visibility),
             cancellationToken);
 
         return result.ToHttpResult();
@@ -185,17 +185,17 @@ public static class PlayListEndpoints
     private static async Task<IResult> DeletePlayList(
         IMediator mediator,
         CurrentUser currentUser,
-        Guid playlistId,
+        Guid id,
         CancellationToken cancellationToken)
     {
-        var result = await mediator.Send(new DeletePlayListCommand(currentUser.RequiredId, playlistId), cancellationToken);
+        var result = await mediator.Send(new DeletePlayListCommand(currentUser.RequiredId, id), cancellationToken);
         return result.ToHttpResult();
     }
 
     private static async Task<IResult> RequestPlayListPictureUpload(
         IMediator mediator,
         CurrentUser currentUser,
-        RequestPlayListPictureUploadRequest request,
+        PictureUploadRequest request,
         CancellationToken cancellationToken)
     {
         var result = await mediator.Send(
@@ -222,12 +222,12 @@ public static class PlayListEndpoints
     private static async Task<IResult> RemoveTrackFromPlayList(
         IMediator mediator,
         CurrentUser currentUser,
-        Guid playlistId,
+        Guid id,
         Guid trackId,
         CancellationToken cancellationToken)
     {
         var result = await mediator.Send(
-            new RemoveTrackFromPlayListCommand(currentUser.RequiredId, playlistId, trackId),
+            new RemoveTrackFromPlayListCommand(currentUser.RequiredId, id, trackId),
             cancellationToken);
 
         return result.ToHttpResult();

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

@@ -3,9 +3,9 @@ using Musify.Api.Authentication;
 using Musify.Api.DataTransferObjects.Tracks;
 using Musify.Api.Extensions;
 using Musify.Api.Filters;
+using Musify.Api.Models;
 using Musify.Application.Contracts;
 using Musify.Application.Pictures;
-using Musify.Api.Models;
 using Musify.Application.Shared;
 using Musify.Application.Tracks;
 using Musify.Application.Tracks.Responses;
@@ -22,47 +22,47 @@ public static class TrackEndpoints
         group.MapGet("/", GetTracks)
             .AddEndpointFilter<ValidationFilter<PageQuery>>()
             .WithName("GetTracks")
-            .WithSummary("Get Paginated Tracks, Optionally Filtered By Name And Genre.")
+            .WithSummary("Get paginated tracks, optionally filtered by name and genre")
             .Produces<PaginatedResponse<TrackApplicationResponse>>()
             .ProducesValidationProblem();
 
-        group.MapGet("/{id}", GetTrackById)
+        group.MapGet("/{id:guid}", GetTrackById)
             .WithName("GetTrackById")
-            .WithSummary("Get A Track By Id.")
+            .WithSummary("Get a track by id")
             .Produces<TrackApplicationResponse>()
             .Produces(StatusCodes.Status404NotFound);
 
-        group.MapGet("/{id}/cover", GetTrackCover)
+        group.MapGet("/{id:guid}/cover", GetTrackCover)
             .WithName("GetTrackCover")
-            .WithSummary("Get A Track Cover Image.")
+            .WithSummary("Get a track cover image")
             .Produces(StatusCodes.Status200OK)
             .Produces(StatusCodes.Status404NotFound);
 
-        group.MapGet("/{id}/stream", GetTrackStream)
+        group.MapGet("/{id:guid}/stream", GetTrackStream)
             .WithName("GetTrackStream")
-            .WithSummary("Get A Streaming Manifest URL And Ticket For A Track. Works Anonymously When The Playback Configuration Allows It.")
+            .WithSummary("Get a streaming manifest URL and ticket for a track. Works anonymously when the playback configuration allows it")
             .Produces<TrackStreamResponse>()
             .Produces(StatusCodes.Status401Unauthorized)
             .Produces(StatusCodes.Status404NotFound);
 
-        group.MapPut("/listens/{listenId}/progress", RecordListeningProgress)
+        group.MapPut("/listens/{listenId:guid}/progress", RecordListeningProgress)
             .AddEndpointFilter<ValidationFilter<RecordListeningProgressRequest>>()
             .WithName("RecordListeningProgress")
-            .WithSummary("Report The Total Seconds Actually Played For A Listen Started By The Stream Endpoint.")
+            .WithSummary("Report the total seconds actually played for a listen started by the stream endpoint")
             .RequireAuthorization()
             .Produces(StatusCodes.Status204NoContent)
             .Produces(StatusCodes.Status401Unauthorized)
             .Produces(StatusCodes.Status404NotFound);
 
-        group.MapGet("/users/{userId}", GetTracksByUserId)
+        group.MapGet("/users/{userId:long}", GetTracksByUserId)
             .AddEndpointFilter<ValidationFilter<PageQuery>>()
             .WithName("GetTracksByUserId")
-            .WithSummary("Get Paginated Tracks For A User.")
+            .WithSummary("Get paginated tracks for a user")
             .Produces<PaginatedResponse<TrackApplicationResponse>>();
 
         group.MapPost("/", CreateTrack)
             .WithName("CreateTrack")
-            .WithSummary("Create A New Track.")
+            .WithSummary("Create a new track")
             .AddEndpointFilter<ValidationFilter<CreateTrackRequest>>()
             .RequireAuthorization()
             .Produces<TrackApplicationResponse>(StatusCodes.Status201Created)
@@ -71,9 +71,9 @@ public static class TrackEndpoints
             .Produces(StatusCodes.Status404NotFound)
             .Produces(StatusCodes.Status409Conflict);
 
-        group.MapDelete("/{trackId}", DeleteTrack)
+        group.MapDelete("/{id:guid}", DeleteTrack)
             .WithName("DeleteTrack")
-            .WithSummary("Delete A Track.")
+            .WithSummary("Delete a track")
             .RequireAuthorization()
             .Produces(StatusCodes.Status204NoContent)
             .Produces(StatusCodes.Status401Unauthorized)
@@ -83,7 +83,7 @@ public static class TrackEndpoints
 
         group.MapPost("/upload-urls", RequestTrackUploadUrls)
             .WithName("RequestTrackUploadUrls")
-            .WithSummary("Request Pre-Signed URLs To Upload Track Picture And Audio.")
+            .WithSummary("Request pre-signed URLs to upload track picture and audio")
             .AddEndpointFilter<ValidationFilter<RequestTrackUploadUrlsRequest>>()
             .RequireAuthorization()
             .Produces<TrackUploadUrlsResponse>()
@@ -176,10 +176,10 @@ public static class TrackEndpoints
     private static async Task<IResult> DeleteTrack(
         IMediator mediator,
         CurrentUser currentUser,
-        Guid trackId,
+        Guid id,
         CancellationToken cancellationToken)
     {
-        var result = await mediator.Send(new DeleteTrackCommand(currentUser.RequiredId, trackId), cancellationToken);
+        var result = await mediator.Send(new DeleteTrackCommand(currentUser.RequiredId, id), cancellationToken);
         return result.ToHttpResult();
     }
 

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

@@ -1,13 +1,13 @@
 using Mediator;
 using Musify.Api.Authentication;
 using Musify.Api.Extensions;
+using Musify.Api.Filters;
 using Musify.Api.Models;
 using Musify.Application.Shared;
 using Musify.Application.Tracks;
 using Musify.Application.Tracks.Responses;
 using Musify.Application.Users;
 using Musify.Application.Users.Responses;
-using Musify.Api.Filters;
 
 namespace Musify.Api.Endpoints;
 
@@ -21,75 +21,75 @@ public static class UserEndpoints
         group.MapGet("/", GetUsers)
             .AddEndpointFilter<ValidationFilter<PageQuery>>()
             .WithName("GetUsers")
-            .WithSummary("Get Paginated Users.")
+            .WithSummary("Get paginated users")
             .Produces<PaginatedResponse<UserSummaryResponse>>();
 
-        group.MapGet("/{id}", GetUserById)
+        group.MapGet("/{id:long}", GetUserById)
             .WithName("GetUserById")
-            .WithSummary("Get A User By Id.")
+            .WithSummary("Get a user by id")
             .Produces<UserApplicationResponse>()
             .Produces(StatusCodes.Status404NotFound);
 
-        group.MapGet("/{id}/listening-history", GetListeningHistory)
+        group.MapGet("/{id:long}/listening-history", GetListeningHistory)
             .WithName("GetListeningHistory")
-            .WithSummary("Get A User'S Listening History.")
+            .WithSummary("Get a user's listening history")
             .Produces<IEnumerable<TrackApplicationResponse>>()
             .Produces(StatusCodes.Status404NotFound);
 
-        group.MapGet("/{id}/listening-stats", GetListeningStats)
+        group.MapGet("/{id:long}/listening-stats", GetListeningStats)
             .WithName("GetListeningStats")
-            .WithSummary("Get A User'S Listening Stats For The Current Week And Streak.")
+            .WithSummary("Get a user's listening stats for the current week and streak")
             .RequireAuthorization()
             .Produces<ListeningStatsResponse>()
             .Produces(StatusCodes.Status401Unauthorized)
             .Produces(StatusCodes.Status403Forbidden);
 
-        group.MapGet("/{id}/last-listened-track", GetLastTrackListenedByUserId)
+        group.MapGet("/{id:long}/last-listened-track", GetLastTrackListenedByUserId)
             .WithName("GetLastTrackListenedByUserId")
-            .WithSummary("Get The Last Track A User Listened To.")
+            .WithSummary("Get the last track a user listened to")
             .Produces<TrackApplicationResponse>()
             .Produces(StatusCodes.Status204NoContent);
 
-        group.MapGet("/{id}/profile", GetUserProfile)
+        group.MapGet("/{id:long}/profile", GetUserProfile)
             .WithName("GetUserProfile")
-            .WithSummary("Get A User'S Public Profile, Including Follower Counts.")
+            .WithSummary("Get a user's public profile, including follower counts")
             .Produces<UserProfileResponse>()
             .Produces(StatusCodes.Status404NotFound);
 
-        group.MapGet("/{id}/followers", GetFollowers)
+        group.MapGet("/{id:long}/followers", GetFollowers)
             .AddEndpointFilter<ValidationFilter<PageQuery>>()
             .WithName("GetUserFollowers")
-            .WithSummary("Get The Users Following A User. Visible To The User And To Mutual Followers.")
+            .WithSummary("Get the users following a user. Visible to the user and to mutual followers")
             .Produces<PaginatedResponse<UserSummaryResponse>>()
             .Produces(StatusCodes.Status403Forbidden)
             .Produces(StatusCodes.Status404NotFound);
 
-        group.MapGet("/{id}/following", GetFollowing)
+        group.MapGet("/{id:long}/following", GetFollowing)
             .AddEndpointFilter<ValidationFilter<PageQuery>>()
             .WithName("GetUserFollowing")
-            .WithSummary("Get The Users A User Follows.")
+            .WithSummary("Get the users a user follows")
             .Produces<PaginatedResponse<UserSummaryResponse>>()
             .Produces(StatusCodes.Status404NotFound);
 
-        group.MapGet("/{id}/is-following", IsFollowing)
+        group.MapGet("/{id:long}/is-following", IsFollowing)
             .WithName("IsFollowingUser")
-            .WithSummary("Check Whether The Current User Follows Another User.")
+            .WithSummary("Check whether the current user follows another user")
             .RequireAuthorization()
             .Produces<bool>()
             .Produces(StatusCodes.Status401Unauthorized);
 
-        group.MapPost("/{id}/follow", FollowUser)
+        group.MapPost("/{id:long}/follow", FollowUser)
             .WithName("FollowUser")
-            .WithSummary("Follow A User.")
+            .WithSummary("Follow a user")
             .RequireAuthorization()
             .Produces(StatusCodes.Status204NoContent)
             .Produces(StatusCodes.Status401Unauthorized)
             .Produces(StatusCodes.Status404NotFound)
             .ProducesValidationProblem();
 
-        group.MapDelete("/{id}/follow", UnfollowUser)
+        group.MapDelete("/{id:long}/follow", UnfollowUser)
             .WithName("UnfollowUser")
-            .WithSummary("Unfollow A User.")
+            .WithSummary("Unfollow a user")
             .RequireAuthorization()
             .Produces(StatusCodes.Status204NoContent)
             .Produces(StatusCodes.Status401Unauthorized);
@@ -117,12 +117,13 @@ public static class UserEndpoints
         return result.ToHttpResult();
     }
 
-    private static async Task<IEnumerable<TrackApplicationResponse>> GetListeningHistory(
+    private static async Task<IResult> GetListeningHistory(
         IMediator mediator,
         long id,
         CancellationToken cancellationToken)
     {
-        return await mediator.Send(new GetListeningHistoryQuery(id), cancellationToken);
+        var result = await mediator.Send(new GetListeningHistoryQuery(id), cancellationToken);
+        return Results.Ok(result);
     }
 
     private static async Task<IResult> GetListeningStats(
@@ -132,9 +133,10 @@ public static class UserEndpoints
         CancellationToken cancellationToken)
     {
         if (currentUser.RequiredId != id)
-            return Results.StatusCode(StatusCodes.Status403Forbidden);
+            return Results.Problem(statusCode: StatusCodes.Status403Forbidden);
 
-        return Results.Ok(await mediator.Send(new GetListeningStatsQuery(id), cancellationToken));
+        var result = await mediator.Send(new GetListeningStatsQuery(id), cancellationToken);
+        return Results.Ok(result);
     }
 
     private static async Task<IResult> GetLastTrackListenedByUserId(
@@ -178,13 +180,14 @@ public static class UserEndpoints
         return result.ToHttpResult();
     }
 
-    private static async Task<bool> IsFollowing(
+    private static async Task<IResult> IsFollowing(
         IMediator mediator,
         CurrentUser currentUser,
         long id,
         CancellationToken cancellationToken)
     {
-        return await mediator.Send(new IsFollowingUserQuery(currentUser.RequiredId, id), cancellationToken);
+        var result = await mediator.Send(new IsFollowingUserQuery(currentUser.RequiredId, id), cancellationToken);
+        return Results.Ok(result);
     }
 
     private static async Task<IResult> FollowUser(

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

@@ -9,9 +9,9 @@ namespace Musify.Api.OpenApi;
 public sealed class OpenApiOptionsSetup(IOptions<AuthenticationConfiguration> options)
     : IConfigureNamedOptions<OpenApiOptions>
 {
-    private const string SecuritySchemeId = "OAuth2";
+    internal const string SecuritySchemeId = "OAuth2";
 
-    private readonly AuthenticationConfiguration _configuration = options.Value;
+    private readonly AuthenticationConfiguration configuration = options.Value;
 
     public void Configure(string? name, OpenApiOptions options) => Configure(options);
 
@@ -28,9 +28,9 @@ public sealed class OpenApiOptionsSetup(IOptions<AuthenticationConfiguration> op
                 {
                     AuthorizationCode = new OpenApiOAuthFlow
                     {
-                        AuthorizationUrl = new Uri(_configuration.AuthorizationEndpoint),
+                        AuthorizationUrl = new Uri(configuration.AuthorizationEndpoint),
-                        TokenUrl = new Uri(_configuration.TokenEndpoint),
+                        TokenUrl = new Uri(configuration.TokenEndpoint),
-                        Scopes = _configuration.Scopes.ToDictionary(scope => scope, scope => scope),
+                        Scopes = configuration.Scopes.ToDictionary(scope => scope, scope => scope),
                     },
                 },
             };
@@ -57,6 +57,16 @@ public sealed class OpenApiOptionsSetup(IOptions<AuthenticationConfiguration> op
 
         options.AddOperationTransformer((operation, context, _) =>
         {
+            // Route parameters constrained with :long are user ids, which travel as strings like every other long.
+            foreach (var parameter in operation.Parameters?.OfType<OpenApiParameter>() ?? [])
+            {
+                if (parameter.Schema is OpenApiSchema { Type: JsonSchemaType.Integer, Format: "int64" } schema)
+                {
+                    schema.Type = JsonSchemaType.String;
+                    schema.Format = null;
+                }
+            }
+
             var requiresAuthorization = context.Description.ActionDescriptor.EndpointMetadata
                 .OfType<IAuthorizeData>()
                 .Any();
@@ -66,15 +76,13 @@ public sealed class OpenApiOptionsSetup(IOptions<AuthenticationConfiguration> op
                 .Any();
 
             if (!requiresAuthorization || allowsAnonymous)
-            {
                 return Task.CompletedTask;
-            }
 
             operation.Security ??= new List<OpenApiSecurityRequirement>();
             operation.Security.Add(new OpenApiSecurityRequirement
             {
                 [new OpenApiSecuritySchemeReference(SecuritySchemeId, context.Document)] =
-                    _configuration.Scopes.ToList(),
+                    configuration.Scopes.ToList(),
             });
 
             return Task.CompletedTask;

backend/Hosts/Musify.Api/Program.cs

@@ -5,7 +5,9 @@ using Musify.Api.Serialization;
 using Musify.Infrastructure.Observability;
 using Scalar.AspNetCore;
 
-var builder = WebApplication.CreateBuilder();
+const string DevCorsPolicy = "dev-cors";
+
+var builder = WebApplication.CreateBuilder(args);
 
 builder.Services.ConfigureHttpJsonOptions(options =>
 {
@@ -14,17 +16,16 @@ builder.Services.ConfigureHttpJsonOptions(options =>
     options.SerializerOptions.Converters.Add(new NullableLongAsStringConverter());
 });
 
-const string devCorsPolicy = "dev-cors";
-
 builder.Services
     .AddApplicationServices(builder.Configuration)
     .AddObservability(builder.Configuration);
 
 builder.Services.AddProblemDetails();
+builder.Services.Configure<RouteHandlerOptions>(options => options.ThrowOnBadRequest = false);
 
 if (builder.Environment.IsDevelopment())
 {
-    builder.Services.AddCors(options => options.AddPolicy(devCorsPolicy, policy =>
+    builder.Services.AddCors(options => options.AddPolicy(DevCorsPolicy, policy =>
         policy.AllowAnyOrigin().AllowAnyHeader().AllowAnyMethod()));
 }
 
@@ -34,7 +35,7 @@ app.UseExceptionHandler();
 
 if (app.Environment.IsDevelopment())
 {
-    app.UseCors(devCorsPolicy);
+    app.UseCors(DevCorsPolicy);
     app.MapOpenApi();
     app.MapScalarApiReference();
 }

backend/Hosts/Musify.Api/Scalar/ScalarOptionsSetup.cs

@@ -1,5 +1,6 @@
 using Microsoft.Extensions.Options;
 using Musify.Api.Authentication;
+using Musify.Api.OpenApi;
 using Scalar.AspNetCore;
 
 namespace Musify.Api.Scalar;
@@ -7,25 +8,23 @@ namespace Musify.Api.Scalar;
 public sealed class ScalarOptionsSetup(IOptions<AuthenticationConfiguration> options)
     : IConfigureOptions<ScalarOptions>
 {
-    private const string SecuritySchemeId = "OAuth2";
+    private readonly AuthenticationConfiguration configuration = options.Value;
-
-    private readonly AuthenticationConfiguration _configuration = options.Value;
 
     public void Configure(ScalarOptions scalarOptions)
     {
         scalarOptions
             .WithTitle("Musify API")
-            .AddPreferredSecuritySchemes(SecuritySchemeId)
+            .AddPreferredSecuritySchemes(OpenApiOptionsSetup.SecuritySchemeId)
-            .AddAuthorizationCodeFlow(SecuritySchemeId, flow =>
+            .AddAuthorizationCodeFlow(OpenApiOptionsSetup.SecuritySchemeId, flow =>
             {
-                flow.ClientId = _configuration.ClientId;
+                flow.ClientId = configuration.ClientId;
-                flow.ClientSecret = _configuration.ClientSecret;
+                flow.ClientSecret = configuration.ClientSecret;
-                flow.AuthorizationUrl = _configuration.AuthorizationEndpoint;
+                flow.AuthorizationUrl = configuration.AuthorizationEndpoint;
-                flow.TokenUrl = _configuration.TokenEndpoint;
+                flow.TokenUrl = configuration.TokenEndpoint;
                 flow.Pkce = Pkce.Sha256;
-                flow.SelectedScopes = _configuration.Scopes;
+                flow.SelectedScopes = configuration.Scopes;
-                flow.RedirectUri = _configuration.ScalarRedirectUri;
+                flow.RedirectUri = configuration.ScalarRedirectUri;
-                flow.RefreshUrl = _configuration.TokenEndpoint;
+                flow.RefreshUrl = configuration.TokenEndpoint;
             })
             .HideModels();
     }

backend/Hosts/Musify.Api/Validators/Albums/AlbumReleaseYear.cs

@@ -1,8 +0,0 @@
-namespace Musify.Api.Validators.Albums;
-
-public static class AlbumReleaseYear
-{
-    public const int Earliest = 1877;
-
-    public static int Latest => DateTime.UtcNow.Year + 1;
-}

backend/Hosts/Musify.Api/Validators/Albums/CreateAlbumRequestValidator.cs

@@ -9,13 +9,13 @@ public sealed class CreateAlbumRequestValidator : AbstractValidator<CreateAlbumR
     {
         RuleFor(x => x.Title)
             .NotEmpty()
-            .MaximumLength(200);
+            .MaximumLength(Limits.AlbumTitle);
 
         RuleFor(x => x.Description)
-            .MaximumLength(256);
+            .MaximumLength(Limits.Description);
 
         RuleFor(x => x.ReleaseYear)
-            .InclusiveBetween(AlbumReleaseYear.Earliest, AlbumReleaseYear.Latest)
+            .InclusiveBetween(Limits.EarliestReleaseYear, Limits.LatestReleaseYear)
             .When(x => x.ReleaseYear.HasValue);
 
         RuleFor(x => x.PictureIntentId)

backend/Hosts/Musify.Api/Validators/Albums/UpdateAlbumRequestValidator.cs

@@ -7,15 +7,15 @@ public sealed class UpdateAlbumRequestValidator : AbstractValidator<UpdateAlbumR
 {
     public UpdateAlbumRequestValidator()
     {
-        RuleFor(x => x.NewTitle)
+        RuleFor(x => x.Title)
             .NotEmpty()
-            .MaximumLength(200);
+            .MaximumLength(Limits.AlbumTitle);
 
-        RuleFor(x => x.NewDescription)
+        RuleFor(x => x.Description)
-            .MaximumLength(256);
+            .MaximumLength(Limits.Description);
 
-        RuleFor(x => x.NewReleaseYear)
+        RuleFor(x => x.ReleaseYear)
-            .InclusiveBetween(AlbumReleaseYear.Earliest, AlbumReleaseYear.Latest)
+            .InclusiveBetween(Limits.EarliestReleaseYear, Limits.LatestReleaseYear)
-            .When(x => x.NewReleaseYear.HasValue);
+            .When(x => x.ReleaseYear.HasValue);
     }
 }

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

@@ -0,0 +1,12 @@
+namespace Musify.Api.Validators;
+
+public static class Limits
+{
+    public const int TrackTitle = 200;
+    public const int AlbumTitle = 200;
+    public const int PlayListName = 50;
+    public const int Description = 256;
+    public const int EarliestReleaseYear = 1877;
+
+    public static int LatestReleaseYear => DateTime.UtcNow.Year + 1;
+}

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

@@ -1,12 +1,12 @@
 using FluentValidation;
-using Musify.Api.DataTransferObjects.Albums;
+using Musify.Api.DataTransferObjects;
 using Musify.Application.Configuration;
 
-namespace Musify.Api.Validators.Albums;
+namespace Musify.Api.Validators;
 
-public sealed class RequestAlbumPictureUploadRequestValidator : AbstractValidator<RequestAlbumPictureUploadRequest>
+public sealed class PictureUploadRequestValidator : AbstractValidator<PictureUploadRequest>
 {
-    public RequestAlbumPictureUploadRequestValidator(UploadIntentConfiguration uploadConfiguration)
+    public PictureUploadRequestValidator(UploadIntentConfiguration uploadConfiguration)
     {
         RuleFor(x => x.FileType)
             .MustBeFileType(Uploads.PictureFileTypes);

backend/Hosts/Musify.Api/Validators/PlayLists/CreatePlayListRequestValidator.cs

@@ -9,10 +9,10 @@ public sealed class CreatePlayListRequestValidator : AbstractValidator<CreatePla
     {
         RuleFor(x => x.Name)
             .NotEmpty()
-            .MaximumLength(50);
+            .MaximumLength(Limits.PlayListName);
 
         RuleFor(x => x.Description)
-            .MaximumLength(256);
+            .MaximumLength(Limits.Description);
 
         RuleFor(x => x.Visibility)
             .IsInEnum();

backend/Hosts/Musify.Api/Validators/PlayLists/RequestPlayListPictureUploadRequestValidator.cs

@@ -1,20 +0,0 @@
-using FluentValidation;
-using Musify.Api.DataTransferObjects.PlayLists;
-using Musify.Application.Configuration;
-
-namespace Musify.Api.Validators.PlayLists;
-
-public sealed class RequestPlayListPictureUploadRequestValidator : AbstractValidator<RequestPlayListPictureUploadRequest>
-{
-    public RequestPlayListPictureUploadRequestValidator(UploadIntentConfiguration uploadConfiguration)
-    {
-        RuleFor(x => x.FileType)
-            .MustBeFileType(Uploads.PictureFileTypes);
-
-        RuleFor(x => x.ContentType)
-            .MustBeContentType(Uploads.PictureContentTypes);
-
-        RuleFor(x => x.ExpectedSizeBytes)
-            .MustBeValidUploadSize(uploadConfiguration.MaxUploadBytes);
-    }
-}

backend/Hosts/Musify.Api/Validators/PlayLists/UpdatePlayListRequestValidator.cs

@@ -7,17 +7,17 @@ public sealed class UpdatePlayListRequestValidator : AbstractValidator<UpdatePla
 {
     public UpdatePlayListRequestValidator()
     {
-        RuleFor(x => x.NewName)
+        RuleFor(x => x.Name)
             .NotEmpty()
-            .MaximumLength(50)
+            .MaximumLength(Limits.PlayListName)
-            .When(x => x.NewName != null);
+            .When(x => x.Name != null);
 
-        RuleFor(x => x.NewDescription)
+        RuleFor(x => x.Description)
-            .MaximumLength(256)
+            .MaximumLength(Limits.Description)
-            .When(x => x.NewDescription != null);
+            .When(x => x.Description != null);
 
-        RuleFor(x => x.NewVisibility)
+        RuleFor(x => x.Visibility)
             .IsInEnum()
-            .When(x => x.NewVisibility != null);
+            .When(x => x.Visibility != null);
     }
 }

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

@@ -10,7 +10,7 @@ public sealed class CreateTrackRequestValidator : AbstractValidator<CreateTrackR
     {
         RuleFor(x => x.Title)
             .NotEmpty()
-            .MaximumLength(200);
+            .MaximumLength(Limits.TrackTitle);
 
         RuleFor(x => x.PictureIntentId)
             .NotEmpty();

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

@@ -1,5 +1,6 @@
 using System.Net;
 using System.Net.Http.Json;
+using Musify.Api.DataTransferObjects;
 using Musify.Api.DataTransferObjects.Albums;
 using Musify.Api.Tests.TestSupport;
 using Musify.Application.Albums.Responses;
@@ -26,7 +27,7 @@ public sealed class AlbumEndpointsTests(ApiTestFixture fixture)
 
         var response = await client.PostAsJsonAsync(
             "/albums/upload-picture",
-            new RequestAlbumPictureUploadRequest("webp", "image/webp"),
+            new PictureUploadRequest("webp", "image/webp"),
             TestContext.Current.CancellationToken);
         response.EnsureSuccessStatusCode();
 

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

@@ -1,4 +1,5 @@
 using Musify.Api.DataTransferObjects.Albums;
+using Musify.Api.Validators;
 using Musify.Api.Validators.Albums;
 using Xunit;
 
@@ -44,7 +45,7 @@ public sealed class CreateAlbumRequestValidatorTests
     [Fact]
     public void Validate_ReleaseYearBeforeTheEarliestBoundary_Fails()
     {
-        var result = validator.Validate(new CreateAlbumRequest("Title", null, AlbumReleaseYear.Earliest - 1, Guid.NewGuid()));
+        var result = validator.Validate(new CreateAlbumRequest("Title", null, Limits.EarliestReleaseYear - 1, Guid.NewGuid()));
 
         Assert.False(result.IsValid);
     }
@@ -52,7 +53,7 @@ public sealed class CreateAlbumRequestValidatorTests
     [Fact]
     public void Validate_ReleaseYearAtTheEarliestBoundary_Passes()
     {
-        var result = validator.Validate(new CreateAlbumRequest("Title", null, AlbumReleaseYear.Earliest, Guid.NewGuid()));
+        var result = validator.Validate(new CreateAlbumRequest("Title", null, Limits.EarliestReleaseYear, Guid.NewGuid()));
 
         Assert.True(result.IsValid);
     }
@@ -60,7 +61,7 @@ public sealed class CreateAlbumRequestValidatorTests
     [Fact]
     public void Validate_ReleaseYearAtTheLatestBoundary_Passes()
     {
-        var result = validator.Validate(new CreateAlbumRequest("Title", null, AlbumReleaseYear.Latest, Guid.NewGuid()));
+        var result = validator.Validate(new CreateAlbumRequest("Title", null, Limits.LatestReleaseYear, Guid.NewGuid()));
 
         Assert.True(result.IsValid);
     }
@@ -68,7 +69,7 @@ public sealed class CreateAlbumRequestValidatorTests
     [Fact]
     public void Validate_ReleaseYearPastTheLatestBoundary_Fails()
     {
-        var result = validator.Validate(new CreateAlbumRequest("Title", null, AlbumReleaseYear.Latest + 1, Guid.NewGuid()));
+        var result = validator.Validate(new CreateAlbumRequest("Title", null, Limits.LatestReleaseYear + 1, Guid.NewGuid()));
 
         Assert.False(result.IsValid);
     }

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

@@ -1,6 +1,6 @@
-using Musify.Api.DataTransferObjects.Albums;
+using Musify.Api.DataTransferObjects;
 using Musify.Api.DataTransferObjects.Tracks;
-using Musify.Api.Validators.Albums;
+using Musify.Api.Validators;
 using Musify.Api.Validators.Tracks;
 using Musify.Application.Configuration;
 using Xunit;
@@ -14,9 +14,9 @@ public sealed class UploadRequestValidatorTests
     [Fact]
     public void PictureUpload_ValidRequest_Passes()
     {
-        var validator = new RequestAlbumPictureUploadRequestValidator(configuration);
+        var validator = new PictureUploadRequestValidator(configuration);
 
-        var result = validator.Validate(new RequestAlbumPictureUploadRequest("webp", "image/webp", 500));
+        var result = validator.Validate(new PictureUploadRequest("webp", "image/webp", 500));
 
         Assert.True(result.IsValid);
     }
@@ -30,9 +30,9 @@ public sealed class UploadRequestValidatorTests
     [InlineData("webp", "image/webp", 1_001L)]
     public void PictureUpload_InvalidRequest_Fails(string fileType, string contentType, long size)
     {
-        var validator = new RequestAlbumPictureUploadRequestValidator(configuration);
+        var validator = new PictureUploadRequestValidator(configuration);
 
-        var result = validator.Validate(new RequestAlbumPictureUploadRequest(fileType, contentType, size));
+        var result = validator.Validate(new PictureUploadRequest(fileType, contentType, size));
 
         Assert.False(result.IsValid);
     }

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

@@ -40,8 +40,8 @@ export async function addAlbumToPlaylistAction({ request, params, locals, fetch
 	}
 
 	const api = createApiClient({ fetch, accessToken });
-	const { data: tracks, error: tracksErr } = await api.GET('/albums/{albumId}/tracks', {
+	const { data: tracks, error: tracksErr } = await api.GET('/albums/{id}/tracks', {
-		params: { path: { albumId }, query: { pageNumber: 1, pageSize: ALBUM_TRACKS_PAGE_SIZE } }
+		params: { path: { id: albumId }, query: { pageNumber: 1, pageSize: ALBUM_TRACKS_PAGE_SIZE } }
 	});
 
 	if (tracksErr || !tracks) {

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

@@ -18,9 +18,9 @@ export const load: PageServerLoad = async ({ params, locals, url, fetch, parent
 
 	const [albumRes, tracksRes, libraryRes] = await Promise.all([
 		api.GET('/albums/{id}', { params: { path: { id: params.id } } }),
-		api.GET('/albums/{albumId}/tracks', {
+		api.GET('/albums/{id}/tracks', {
 			params: {
-				path: { albumId: params.id },
+				path: { id: params.id },
 				query: { pageNumber: 1, pageSize: ALBUM_TRACKS_PAGE_SIZE }
 			}
 		}),
@@ -71,8 +71,8 @@ export const actions: Actions = {
 		if (!trackId) return fail(400, { message: 'Falta la canción.' });
 
 		const api = createApiClient({ fetch, accessToken });
-		const result = await api.DELETE('/albums/{albumId}/tracks/{trackId}', {
+		const result = await api.DELETE('/albums/{id}/tracks/{trackId}', {
-			params: { path: { albumId: params.id, trackId } }
+			params: { path: { id: params.id, trackId } }
 		});
 		const failure = unwrapOrFail(result, 'No se pudo quitar la canción.');
 		if (failure) return failure;
@@ -102,13 +102,13 @@ export const actions: Actions = {
 			newPictureIntentId = uploaded.intentId;
 		}
 
-		const result = await api.PUT('/albums/{albumId}', {
+		const result = await api.PUT('/albums/{id}', {
-			params: { path: { albumId: params.id } },
+			params: { path: { id: params.id } },
 			body: {
-				newTitle: parsed.body.title,
+				title: parsed.body.title,
-				newDescription: parsed.body.description,
+				description: parsed.body.description,
-				newReleaseYear: parsed.body.releaseYear,
+				releaseYear: parsed.body.releaseYear,
-				newPictureIntentId
+				pictureIntentId: newPictureIntentId
 			}
 		});
 		const failure = unwrapOrFail(result, 'No se pudo actualizar el álbum.');
@@ -121,8 +121,8 @@ export const actions: Actions = {
 		if (typeof accessToken !== 'string') return accessToken;
 
 		const api = createApiClient({ fetch, accessToken });
-		const result = await api.DELETE('/albums/{albumId}', {
+		const result = await api.DELETE('/albums/{id}', {
-			params: { path: { albumId: params.id } }
+			params: { path: { id: params.id } }
 		});
 		const failure = unwrapOrFail(result, 'No se pudo eliminar el álbum.');
 		if (failure) return failure;

web-player/src/routes/(app)/library/+page.server.ts

@@ -28,8 +28,8 @@ export const actions: Actions = {
 		if (!trackId) return fail(400, { message: 'Falta la canción.' });
 
 		const api = createApiClient({ fetch, accessToken });
-		const result = await api.DELETE('/tracks/{trackId}', {
+		const result = await api.DELETE('/tracks/{id}', {
-			params: { path: { trackId } }
+			params: { path: { id: trackId } }
 		});
 		const failure = unwrapOrFail(result, 'No se pudo borrar la canción.');
 		if (failure) return failure;

web-player/src/routes/(app)/playlists/+page.server.ts

@@ -26,8 +26,8 @@ export const load: PageServerLoad = async ({ locals, url, fetch }) => {
 			fetchAllPages(
 				async (pageNumber, pageSize) =>
 					(
-						await api.GET('/playlists/{playlistId}/tracks', {
+						await api.GET('/playlists/{id}/tracks', {
-							params: { path: { playlistId: playlist.id }, query: { pageNumber, pageSize } }
+							params: { path: { id: playlist.id }, query: { pageNumber, pageSize } }
 						})
 					).data,
 				PLAYLIST_TRACKS_LIMIT

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

@@ -23,8 +23,8 @@ export const load: PageServerLoad = async ({ params, locals, url, fetch, parent
 		fetchAllPages(
 			async (pageNumber, pageSize) =>
 				(
-					await api.GET('/playlists/{playlistId}/tracks', {
+					await api.GET('/playlists/{id}/tracks', {
-						params: { path: { playlistId: params.id }, query: { pageNumber, pageSize } }
+						params: { path: { id: params.id }, query: { pageNumber, pageSize } }
 					})
 				).data,
 			PLAYLIST_TRACKS_LIMIT
@@ -44,8 +44,8 @@ export const actions: Actions = {
 		if (!trackId) return fail(400, { message: 'Falta la canción.' });
 
 		const api = createApiClient({ fetch, accessToken });
-		const result = await api.DELETE('/playlists/{playlistId}/tracks/{trackId}', {
+		const result = await api.DELETE('/playlists/{id}/tracks/{trackId}', {
-			params: { path: { playlistId: params.id, trackId } }
+			params: { path: { id: params.id, trackId } }
 		});
 		const failure = unwrapOrFail(result, 'No se pudo quitar la canción.');
 		if (failure) return failure;
@@ -78,9 +78,14 @@ export const actions: Actions = {
 			newPictureIntentId = result.intentId;
 		}
 
-		const result = await api.PUT('/playlists/{playlistId}', {
+		const result = await api.PUT('/playlists/{id}', {
-			params: { path: { playlistId: params.id } },
+			params: { path: { id: params.id } },
-			body: { newName: name, newDescription: description, newPictureIntentId, newVisibility }
+			body: {
+				name,
+				description,
+				pictureIntentId: newPictureIntentId,
+				visibility: newVisibility
+			}
 		});
 		const failure = unwrapOrFail(result, 'No se pudo actualizar la playlist.');
 		if (failure) return failure;
@@ -92,8 +97,8 @@ export const actions: Actions = {
 		if (typeof accessToken !== 'string') return accessToken;
 
 		const api = createApiClient({ fetch, accessToken });
-		const result = await api.DELETE('/playlists/{playlistId}', {
+		const result = await api.DELETE('/playlists/{id}', {
-			params: { path: { playlistId: params.id } }
+			params: { path: { id: params.id } }
 		});
 		const failure = unwrapOrFail(result, 'No se pudo eliminar la playlist.');
 		if (failure) return failure;

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

@@ -25,8 +25,8 @@ export const load: PageServerLoad = async ({ params, locals, url, fetch, parent
 	const tracksByPlaylist = await Promise.all(
 		playlistItems.map((playlist) =>
 			api
-				.GET('/playlists/{playlistId}/tracks', {
+				.GET('/playlists/{id}/tracks', {
-					params: { path: { playlistId: playlist.id }, query: { pageNumber: 1, pageSize: 1 } }
+					params: { path: { id: playlist.id }, query: { pageNumber: 1, pageSize: 1 } }
 				})
 				.then((res) => Number(res.data?.totalItemCount ?? 0))
 		)

web-player/src/routes/+page.server.ts

@@ -45,9 +45,9 @@ export const load: PageServerLoad = async ({ locals, url, fetch }) => {
 	const spotlightPlaylist = playlistItems[0] ?? null;
 	const spotlightTracksPromise = spotlightPlaylist
 		? api
-				.GET('/playlists/{playlistId}/tracks', {
+				.GET('/playlists/{id}/tracks', {
 					params: {
-						path: { playlistId: spotlightPlaylist.id },
+						path: { id: spotlightPlaylist.id },
 						query: { pageNumber: 1, pageSize: HOME_SPOTLIGHT_TRACKS_LIMIT }
 					}
 				})

web-player/src/routes/api/albums/[id]/tracks/+server.ts

@@ -5,9 +5,9 @@ import { ALBUM_TRACKS_PAGE_SIZE } from '$lib/config';
 
 export const GET: RequestHandler = async ({ params, locals, fetch }) => {
 	const api = createApiClient({ fetch, accessToken: locals.accessToken ?? undefined });
-	const result = await api.GET('/albums/{albumId}/tracks', {
+	const result = await api.GET('/albums/{id}/tracks', {
 		params: {
-			path: { albumId: params.id },
+			path: { id: params.id },
 			query: { pageNumber: 1, pageSize: ALBUM_TRACKS_PAGE_SIZE }
 		}
 	});