NotS1mp/Musify
0
0
Fork 0
Code Issues 23 Pull Requests Actions Packages Projects Releases Wiki Activity

Generalize YouTube-backed endpoints behind a source parameter

Browse Source 
Removes the last YouTube-specific routes (/youtube/*) and merges them
into the general track/album/playlist endpoints, keyed by a `source`
string validated against TrackSource. This mirrors the earlier track
search merge for albums and playlist-track additions:

- GetAlbums now merges local albums with live YouTube Music search
  results, paginated via a youtubeContinuationToken, deduped against
  already-materialized ExternalAlbum rows.
- New GET /albums/external/{source}/{externalId} and
  GET /tracks/external/{source}/{externalId}/stream replace the
  YouTube-only equivalents.
- POST /playlists/{id}/tracks replaces the separate
  .../youtube-tracks endpoint, accepting an optional Source/ExternalId
  pair alongside TrackId.
- AlbumSearchItemResponse/AlbumsSearchResponse follow the same
  discriminated-union + trailing-HasNextPage-field pattern already
  used for track search, so HasNextPage stays a required field in the
  generated OpenAPI schema.
- Frontend routes renamed accordingly (/albums/youtube/[albumId] ->
  /albums/external/[source]/[externalId], etc.) with a single
  /api/thumbnail proxy replacing /api/youtube/thumbnail.

Musify.Api.Endpoints.YouTubeEndpoints and the standalone
SearchYouTubeAlbums query are removed as a result.
This commit is contained in:
Admin
2026-09-10 15:03:36 +02:00
parent c5b2b71eea
commit 29a7fed6a5
29 changed files with 353 additions and 254 deletions
Download Patch File Download Diff File Expand all files Collapse all files
backend/Hosts/Musify.Api/DataTransferObjects/PlayLists/AddPlayListTrackRequest.cs
+8
View File
@@ -0,0 +1,8 @@
using Musify.Domain.ValueObjects;
namespace Musify.Api.DataTransferObjects.PlayLists;
/// <summary>Add a track already in the catalog by <see cref="TrackId"/>, or one from an external
/// source by <see cref="Source"/> + <see cref="ExternalId"/> (provisioning it in the background if
/// needed) — exactly one of the two must be given.</summary>
public record AddPlayListTrackRequest(Guid? TrackId, TrackSource? Source, string? ExternalId);
backend/Hosts/Musify.Api/DataTransferObjects/PlayLists/AddYouTubeTrackRequest.cs
-3
View File
@@ -1,3 +0,0 @@
namespace Musify.Api.DataTransferObjects.PlayLists;
public record AddYouTubeTrackRequest(string VideoId);
backend/Hosts/Musify.Api/Endpoints/AlbumEndpoints.cs
+26 -4
View File
@@ -7,6 +7,8 @@ using Musify.Application.Albums;
using Musify.Application.Albums.Responses;
using Musify.Application.Shared;
using Musify.Application.Tracks.Responses;
using Musify.Application.YouTube;
using Musify.Domain.ValueObjects;
namespace Musify.Api.Endpoints;
@@ -19,8 +21,8 @@ public static class AlbumEndpoints
group.MapGet("/", GetAlbums)
.WithName("GetAlbums")
.WithSummary("Get Paginated Albums.")
.Produces<PaginatedResponse<AlbumApplicationResponse>>();
.WithSummary("Get Paginated Albums, Combined With Live YouTube Music Results When A Title Filter Is Given.")
.Produces<AlbumsSearchResponse>();
group.MapGet("/{id}", GetAlbumById)
.WithName("GetAlbumById")
@@ -28,6 +30,12 @@ public static class AlbumEndpoints
.Produces<AlbumApplicationResponse>()
.Produces(StatusCodes.Status404NotFound);
group.MapGet("/external/{source}/{externalId}", GetExternalAlbum)
.WithName("GetExternalAlbum")
.WithSummary("Get An Album From An External Source (Currently Only YouTube Music) With Its Tracklist.")
.Produces<YouTubeAlbumDetail>()
.Produces(StatusCodes.Status404NotFound);
group.MapGet("/users/{userId}", GetAlbumsByUserId)
.WithName("GetAlbumsByUserId")
.WithSummary("Get Paginated Albums For A User.")
@@ -100,9 +108,10 @@ public static class AlbumEndpoints
CancellationToken cancellationToken,
string? title,
int pageNumber = 1,
int pageSize = 10)
int pageSize = 10,
string? youtubeContinuationToken = null)
{
var result = await mediator.Send(new GetAlbumsQuery(title, pageNumber, pageSize), cancellationToken);
var result = await mediator.Send(new GetAlbumsQuery(title, pageNumber, pageSize, youtubeContinuationToken), cancellationToken);
return result.ToHttpResult();
}
@@ -115,6 +124,19 @@ public static class AlbumEndpoints
return result.ToHttpResult();
}
private static async Task<IResult> GetExternalAlbum(
IMediator mediator,
string source,
string externalId,
CancellationToken cancellationToken)
{
if (!Enum.TryParse<TrackSource>(source, ignoreCase: true, out var trackSource) || trackSource != TrackSource.YouTube)
return Results.NotFound($"Unknown or unsupported source '{source}'.");
var result = await mediator.Send(new GetYouTubeAlbumQuery(externalId), cancellationToken);
return result.ToHttpResult();
}
private static async Task<IResult> GetAlbumsByUserId(
IMediator mediator,
long userId,
backend/Hosts/Musify.Api/Endpoints/PlayListEndpoints.cs
+21 -31
View File
@@ -1,9 +1,11 @@
using Mediator;
using Musify.Application.PlayLists;
using Musify.Application.PlayLists.Responses;
using Musify.Application.Tracks;
using Musify.Application.Tracks.Responses;
using Musify.Application.Shared;
using Musify.Application.Contracts;
using Musify.Domain.ValueObjects;
using Musify.Api.Authentication;
using Musify.Api.DataTransferObjects.PlayLists;
using Musify.Api.Extensions;
@@ -84,19 +86,10 @@ public static class PlayListEndpoints
.Produces(StatusCodes.Status401Unauthorized)
.Produces(StatusCodes.Status404NotFound);
group.MapPost("/{playlistId}/tracks/{trackId}", AddTrackToPlayList)
.WithName("AddTrackToPlayList")
.WithSummary("Add A Track To A PlayList.")
.RequireAuthorization()
.Produces(StatusCodes.Status204NoContent)
.Produces(StatusCodes.Status401Unauthorized)
.Produces(StatusCodes.Status404NotFound)
.Produces(StatusCodes.Status409Conflict);
group.MapPost("/{playlistId}/youtube-tracks", AddYouTubeTrackToPlayList)
.WithName("AddYouTubeTrackToPlayList")
.WithSummary("Add A YouTube Track To A PlayList, Downloading It In The Background If Needed.")
.AddEndpointFilter<ValidationFilter<AddYouTubeTrackRequest>>()
group.MapPost("/{playlistId}/tracks", AddPlayListTrack)
.WithName("AddPlayListTrack")
.WithSummary("Add A Track To A PlayList, By Id Or By External Source, Provisioning It In The Background If Needed.")
.AddEndpointFilter<ValidationFilter<AddPlayListTrackRequest>>()
.RequireAuthorization()
.Produces<TrackApplicationResponse>(StatusCodes.Status201Created)
.ProducesValidationProblem()
@@ -225,32 +218,29 @@ public static class PlayListEndpoints
return result.ToHttpResult();
}
private static async Task<IResult> AddTrackToPlayList(
private static async Task<IResult> AddPlayListTrack(
IMediator mediator,
CurrentUser currentUser,
Guid playlistId,
Guid trackId,
AddPlayListTrackRequest request,
CancellationToken cancellationToken)
{
var result = await mediator.Send(
new AddTrackToPlayListCommand(currentUser.RequiredId, playlistId, trackId),
cancellationToken);
if (request.TrackId is { } trackId)
{
var addResult = await mediator.Send(
new AddTrackToPlayListCommand(currentUser.RequiredId, playlistId, trackId),
cancellationToken);
if (addResult.IsError)
return addResult.ToHttpResult();
return result.ToHttpResult();
}
var trackResult = await mediator.Send(new GetTrackByIdQuery(trackId), cancellationToken);
return trackResult.ToCreatedResult(track => $"/tracks/{track.Id}");
}
private static async Task<IResult> AddYouTubeTrackToPlayList(
IMediator mediator,
CurrentUser currentUser,
Guid playlistId,
AddYouTubeTrackRequest request,
CancellationToken cancellationToken)
{
// The validator guarantees Source/ExternalId are set whenever TrackId isn't, and that Source
// is one of the currently supported external sources (only YouTube for now).
var result = await mediator.Send(
new AddYouTubeTrackToPlayListCommand(
currentUser.RequiredId,
playlistId,
request.VideoId),
new AddYouTubeTrackToPlayListCommand(currentUser.RequiredId, playlistId, request.ExternalId!),
cancellationToken);
return result.ToCreatedResult(track => $"/tracks/{track.Id}");
backend/Hosts/Musify.Api/Endpoints/TrackEndpoints.cs
+25
View File
@@ -3,6 +3,9 @@ using Musify.Application.Tracks;
using Musify.Application.Tracks.Responses;
using Musify.Application.Shared;
using Musify.Application.Contracts;
using Musify.Application.YouTube;
using Musify.Application.YouTube.Responses;
using Musify.Domain.ValueObjects;
using Musify.Api.Authentication;
using Musify.Api.DataTransferObjects.Tracks;
using Musify.Api.Extensions;
@@ -41,6 +44,14 @@ public static class TrackEndpoints
.Produces(StatusCodes.Status401Unauthorized)
.Produces(StatusCodes.Status404NotFound);
group.MapGet("/external/{source}/{externalId}/stream", GetExternalTrackStream)
.WithName("GetExternalTrackStream")
.WithSummary("Resolve Playback For A Track From An External Source (Currently Only YouTube Music): Server Stream If Downloaded, Direct Stream From The Source Otherwise. Works Anonymously When The Playback Configuration Allows It.")
.Produces<YouTubeStreamResponse>()
.Produces(StatusCodes.Status401Unauthorized)
.Produces(StatusCodes.Status404NotFound)
.Produces(StatusCodes.Status409Conflict);
group.MapGet("/users/{userId}", GetTracksByUserId)
.WithName("GetTracksByUserId")
.WithSummary("Get Paginated Tracks For A User.")
@@ -129,6 +140,20 @@ public static class TrackEndpoints
return result.ToHttpResult();
}
private static async Task<IResult> GetExternalTrackStream(
IMediator mediator,
CurrentUser currentUser,
string source,
string externalId,
CancellationToken cancellationToken)
{
if (!Enum.TryParse<TrackSource>(source, ignoreCase: true, out var trackSource) || trackSource != TrackSource.YouTube)
return Results.NotFound($"Unknown or unsupported source '{source}'.");
var result = await mediator.Send(new ResolveYouTubeTrackStreamCommand(externalId, currentUser.Id), cancellationToken);
return result.ToHttpResult();
}
private static async Task<IResult> GetTracksByUserId(
IMediator mediator,
long userId,
backend/Hosts/Musify.Api/Endpoints/YouTubeEndpoints.cs
-78
View File
@@ -1,78 +0,0 @@
using Mediator;
using Musify.Api.Authentication;
using Musify.Api.Extensions;
using Musify.Application.Contracts;
using Musify.Application.YouTube;
using Musify.Application.YouTube.Responses;
namespace Musify.Api.Endpoints;
public static class YouTubeEndpoints
{
public static IEndpointRouteBuilder MapYouTubeEndpoints(this IEndpointRouteBuilder app)
{
var group = app.MapGroup("/youtube")
.WithTags("YouTube");
group.MapGet("/albums", SearchAlbums)
.WithName("SearchYouTubeAlbums")
.WithSummary("Search Albums On YouTube Music.")
.RequireAuthorization()
.Produces<YouTubeAlbumSearchResult>()
.Produces(StatusCodes.Status401Unauthorized)
.ProducesValidationProblem();
group.MapGet("/albums/{albumId}", GetAlbum)
.WithName("GetYouTubeAlbum")
.WithSummary("Get A YouTube Music Album With Its Tracklist.")
.RequireAuthorization()
.Produces<YouTubeAlbumDetail>()
.Produces(StatusCodes.Status401Unauthorized)
.Produces(StatusCodes.Status404NotFound);
group.MapGet("/tracks/{videoId}/stream", GetTrackStream)
.WithName("GetYouTubeTrackStream")
.WithSummary("Resolve Playback For A YouTube Track: Server Stream If Downloaded, Direct YouTube Stream Otherwise. Works Anonymously When The Playback Configuration Allows It.")
.Produces<YouTubeStreamResponse>()
.Produces(StatusCodes.Status401Unauthorized)
.Produces(StatusCodes.Status404NotFound)
.Produces(StatusCodes.Status409Conflict);
return app;
}
private static async Task<IResult> GetTrackStream(
IMediator mediator,
CurrentUser currentUser,
string videoId,
CancellationToken cancellationToken)
{
var result = await mediator.Send(
new ResolveYouTubeTrackStreamCommand(videoId, currentUser.Id),
cancellationToken);
return result.ToHttpResult();
}
private static async Task<IResult> SearchAlbums(
IMediator mediator,
CancellationToken cancellationToken,
string query,
string? continuation = null)
{
var result = await mediator.Send(
new SearchYouTubeAlbumsQuery(query, continuation ?? string.Empty),
cancellationToken);
return result.ToHttpResult();
}
private static async Task<IResult> GetAlbum(
IMediator mediator,
string albumId,
CancellationToken cancellationToken)
{
var result = await mediator.Send(new GetYouTubeAlbumQuery(albumId), cancellationToken);
return result.ToHttpResult();
}
}
backend/Hosts/Musify.Api/Program.cs
+1 -2
View File
@@ -42,8 +42,7 @@ app
.MapMixEndpoints()
.MapPlayListEndpoints()
.MapTrackEndpoints()
.MapUserEndpoints()
.MapYouTubeEndpoints();
.MapUserEndpoints();
app.Run();
backend/Hosts/Musify.Api/Validators/PlayLists/AddPlayListTrackRequestValidator.cs
+27
View File
@@ -0,0 +1,27 @@
using FluentValidation;
using Musify.Api.DataTransferObjects.PlayLists;
using Musify.Domain.ValueObjects;
namespace Musify.Api.Validators.PlayLists;
public sealed class AddPlayListTrackRequestValidator : AbstractValidator<AddPlayListTrackRequest>
{
public AddPlayListTrackRequestValidator()
{
RuleFor(x => x)
.Must(x => x.TrackId.HasValue ^ (x.Source.HasValue && !string.IsNullOrEmpty(x.ExternalId)))
.WithMessage("Provide either trackId, or source and externalId, but not both.");
When(x => x.Source.HasValue, () =>
{
RuleFor(x => x.Source)
.Must(source => source == TrackSource.YouTube)
.WithMessage("Unsupported source.");
RuleFor(x => x.ExternalId)
.NotEmpty()
.Matches("^[A-Za-z0-9_-]{11}$")
.WithMessage("externalId must be a valid YouTube video id.");
});
}
}
backend/Hosts/Musify.Api/Validators/PlayLists/AddYouTubeTrackRequestValidator.cs
-14
View File
@@ -1,14 +0,0 @@
using FluentValidation;
using Musify.Api.DataTransferObjects.PlayLists;
namespace Musify.Api.Validators.PlayLists;
public sealed class AddYouTubeTrackRequestValidator : AbstractValidator<AddYouTubeTrackRequest>
{
public AddYouTubeTrackRequestValidator()
{
RuleFor(x => x.VideoId)
.NotEmpty()
.Matches("^[A-Za-z0-9_-]{11}$");
}
}