Remove YouTube integration from backend and deployment config

Drops the YouTube-backed second catalog source entirely: the
Local/External split on Track/Album collapses into single concrete
entities, Artist/TrackArtist/ExternalTrack/ExternalAlbum and the
YouTube service/download pipeline (yt-dlp, MassTransit consumer,
routing slip) are deleted, and mixes now source discovery only from
local listening history. Includes the RemoveYouTubeIntegration EF
Core migration and matching Worker/deploy/compose cleanup (no more
yt-dlp/python/deno in the Worker image, no thumbnail-cache/YtDlp
config sections).

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

@@ -17,7 +17,7 @@ namespace Musify.Application.Albums
     {
         public async ValueTask<ErrorOr<Success>> Handle(AddTrackToAlbumCommand request, CancellationToken cancellationToken)
         {
-            var album = await database.UserAlbums
+            var album = await database.Albums
                 .AsNoTracking()
                 .SingleOrDefaultAsync(a => a.Id == request.AlbumId, cancellationToken);
             if (album is null)
@@ -32,19 +32,16 @@ namespace Musify.Application.Albums
                 return Error.Unauthorized();
             }
 
-            var trackExists = await database.Tracks
+            var track = await database.Tracks
                 .AsNoTracking()
-                .AnyAsync(t => t.Id == request.TrackId, cancellationToken);
-            if (!trackExists)
+                .SingleOrDefaultAsync(t => t.Id == request.TrackId, cancellationToken);
+            if (track is null)
             {
                 logger.LogInformation("Track {TrackId} not found", request.TrackId);
                 return Error.NotFound(description: $"Track {request.TrackId} not found");
             }
 
-            var localTrack = await database.LocalTracks
-                .AsNoTracking()
-                .SingleOrDefaultAsync(t => t.Id == request.TrackId, cancellationToken);
-            if (localTrack is not null && localTrack.OwnerUserId != request.UserId)
+            if (track.OwnerUserId != request.UserId)
             {
                 logger.LogWarning("User {UserId} does not own track {TrackId}", request.UserId, request.TrackId);
                 return Error.Unauthorized();

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

@@ -50,7 +50,7 @@ namespace Musify.Application.Albums
             var intent = pictureIntent.Value;
             var title = request.Title.Trim();
 
-            var album = new UserAlbum
+            var album = new Album
             {
                 OwnerUserId = request.UserId,
                 Title = title,
@@ -66,7 +66,7 @@ namespace Musify.Application.Albums
                 }
             };
 
-            await database.UserAlbums.AddAsync(album, cancellationToken);
+            await database.Albums.AddAsync(album, cancellationToken);
 
             var finalPictureKey = albumConfiguration.Routes.BuildOriginalPicturePath(request.UserId, intent.ObjectName);
             var publishResult = await PublishCreateAlbumEventAsync(album.Id, intent, finalPictureKey, cancellationToken);

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

@@ -16,7 +16,7 @@ namespace Musify.Application.Albums
     {
         public async ValueTask<ErrorOr<Success>> Handle(DeleteAlbumCommand request, CancellationToken cancellationToken)
         {
-            var album = await database.UserAlbums
+            var album = await database.Albums
                 .SingleOrDefaultAsync(a => a.Id == request.AlbumId, cancellationToken);
             if (album is null)
             {
@@ -30,7 +30,7 @@ namespace Musify.Application.Albums
                 return Error.Unauthorized();
             }
 
-            database.UserAlbums.Remove(album);
+            database.Albums.Remove(album);
 
             try
             {

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

@@ -14,7 +14,7 @@ namespace Musify.Application.Albums
     {
         public async ValueTask<ErrorOr<AlbumApplicationResponse>> Handle(GetAlbumByIdQuery request, CancellationToken cancellationToken)
         {
-            var album = await database.UserAlbums
+            var album = await database.Albums
                 .AsNoTracking()
                 .Where(a => a.Id == request.Id)
                 .Select(a => new

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

@@ -4,7 +4,6 @@ using Microsoft.EntityFrameworkCore;
 using Musify.Application.Contracts;
 using Musify.Application.Shared;
 using Musify.Application.Tracks.Responses;
-using Musify.Domain.Entities;
 using X.PagedList;
 using X.PagedList.EF;
 
@@ -29,9 +28,7 @@ namespace Musify.Application.Albums
 
             var tracksQuery = database.AlbumHasTracks
                 .AsNoTracking()
-                .Include(albumTrack => ((ExternalTrack)albumTrack.Track).TrackArtists)
-                    .ThenInclude(trackArtist => trackArtist.Artist)
-                .Include(albumTrack => ((LocalTrack)albumTrack.Track).Owner)
+                .Include(albumTrack => albumTrack.Track.Owner)
                 .Where(albumTrack => albumTrack.AlbumId == request.AlbumId);
 
             var totalCount = await tracksQuery.CountAsync(cancellationToken);

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

@@ -1,29 +1,19 @@
 using ErrorOr;
 using Mediator;
 using Microsoft.EntityFrameworkCore;
-using Microsoft.Extensions.Logging;
 using Musify.Application.Albums.Responses;
 using Musify.Application.Contracts;
-using Musify.Domain.Entities;
-using Musify.Domain.ValueObjects;
 using X.PagedList;
 using X.PagedList.EF;
 
 namespace Musify.Application.Albums
 {
-    public record GetAlbumsQuery(string? Title, int PageNumber, int PageSize, string? YoutubeContinuationToken = null)
+    public record GetAlbumsQuery(string? Title, int PageNumber, int PageSize)
         : IQuery<ErrorOr<AlbumsSearchResponse>>;
 
-    public class GetAlbumsQueryHandler(
-        IDatabase database,
-        IYouTubeMusicService youTubeMusicService,
-        ILogger<GetAlbumsQueryHandler> logger)
+    public class GetAlbumsQueryHandler(IDatabase database)
         : IQueryHandler<GetAlbumsQuery, ErrorOr<AlbumsSearchResponse>>
     {
-        // Mirrors GetTracksQueryHandler's threshold: a title shorter than this is too likely to
-        // still be mid-keystroke to justify a live call to the external search API.
-        private const int MinTitleLengthForYouTubeSearch = 2;
-
         public async ValueTask<ErrorOr<AlbumsSearchResponse>> Handle(GetAlbumsQuery request, CancellationToken cancellationToken)
         {
             var albumsQuery = database.Albums
@@ -52,62 +42,19 @@ namespace Musify.Application.Albums
                 })
                 .ToPagedListAsync(request.PageNumber, request.PageSize, totalCount, cancellationToken);
 
-            var localItems = pagedEntities
+            var items = pagedEntities
                 .Select(entry => AlbumSearchItemResponse.FromAlbum(
                     AlbumApplicationResponse.FromEntity(entry.Album, entry.TrackCount, entry.CoverTrackIds)))
                 .ToList();
 
-            var knownExternalIds = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
-            foreach (var entry in pagedEntities)
-            {
-                if (entry.Album is ExternalAlbum { Source: TrackSource.YouTube } external)
-                    knownExternalIds.Add(external.ExternalId);
-            }
-
-            var youtubeItems = new List<AlbumSearchItemResponse>();
-            string? nextContinuationToken = null;
-            var youtubeUnavailable = false;
-
-            if (request.Title?.Trim().Length >= MinTitleLengthForYouTubeSearch)
-                (youtubeItems, nextContinuationToken, youtubeUnavailable) =
-                    await SearchYouTubeAsync(request.Title, request.YoutubeContinuationToken, knownExternalIds, cancellationToken);
-
-            return AlbumsSearchResponse.Create(
-                [.. localItems, .. youtubeItems],
+            return new AlbumsSearchResponse(
+                items,
                 pagedEntities.PageNumber,
                 pagedEntities.PageSize,
                 pagedEntities.PageCount,
                 pagedEntities.TotalItemCount,
                 pagedEntities.HasPreviousPage,
-                pagedEntities.HasNextPage,
-                nextContinuationToken,
-                youtubeUnavailable);
-        }
-
-        private async Task<(List<AlbumSearchItemResponse> Items, string? NextContinuationToken, bool Unavailable)> SearchYouTubeAsync(
-            string title,
-            string? continuationToken,
-            HashSet<string> knownExternalIds,
-            CancellationToken cancellationToken)
-        {
-            var searchResult = await youTubeMusicService.SearchAlbumsAsync(title, continuationToken ?? string.Empty, cancellationToken);
-            if (searchResult.IsError)
-            {
-                logger.LogInformation(
-                    "YouTube album search unavailable while combining album results: {Error}", searchResult.FirstError.Description);
-                return ([], null, true);
-            }
-
-            var items = searchResult.Value.Items
-                .Where(album => knownExternalIds.Add(album.AlbumId))
-                .Select(AlbumSearchItemResponse.FromYouTubeAlbum)
-                .ToList();
-
-            var nextToken = string.IsNullOrEmpty(searchResult.Value.ContinuationToken)
-                ? null
-                : searchResult.Value.ContinuationToken;
-
-            return (items, nextToken, false);
+                pagedEntities.HasNextPage);
         }
     }
 }

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

@@ -23,7 +23,7 @@ namespace Musify.Application.Albums
             if (!userExists)
                 return Error.NotFound(description: $"User {request.UserId} not found");
 
-            var albumsQuery = database.UserAlbums
+            var albumsQuery = database.Albums
                 .AsNoTracking()
                 .Where(album => album.OwnerUserId == request.UserId);
 

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

@@ -16,7 +16,7 @@ namespace Musify.Application.Albums
     {
         public async ValueTask<ErrorOr<Success>> Handle(RemoveTrackFromAlbumCommand request, CancellationToken cancellationToken)
         {
-            var album = await database.UserAlbums
+            var album = await database.Albums
                 .AsNoTracking()
                 .SingleOrDefaultAsync(a => a.Id == request.AlbumId, cancellationToken);
             if (album is null)

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

@@ -4,15 +4,6 @@ using Musify.Application.Serialization;
 
 namespace Musify.Application.Albums.Responses
 {
-    // [JsonPolymorphic]/[JsonDerivedType] are required here, not optional: without them
-    // System.Text.Json serializes strictly by the declared CLR type at each call site
-    // (AlbumApplicationResponse, both as a bare return type and nested inside
-    // AlbumSearchItemResponse.Album), so an ExternalAlbumApplicationResponse instance would
-    // silently lose ExternalId/ThumbnailUrl on the wire. This also gives every response a
-    // "source" discriminator field for free, matching AlbumSearchItemResponse.Source.
-    [JsonPolymorphic(TypeDiscriminatorPropertyName = "source")]
-    [JsonDerivedType(typeof(AlbumApplicationResponse), typeDiscriminator: "Local")]
-    [JsonDerivedType(typeof(ExternalAlbumApplicationResponse), typeDiscriminator: "YouTube")]
     public record AlbumApplicationResponse(
         Guid Id,
         string Title,
@@ -30,7 +21,7 @@ namespace Musify.Application.Albums.Responses
         public const int CoverTrackCount = 4;
 
         public static AlbumApplicationResponse FromEntity(
-            UserAlbum album,
+            Album album,
             int trackCount,
             IReadOnlyList<Guid>? coverTrackIds = null)
         {
@@ -48,18 +39,5 @@ namespace Musify.Application.Albums.Responses
                 album.UpdatedAt,
                 coverTrackIds ?? []);
         }
-
-        public static AlbumApplicationResponse FromEntity(
-            Album album,
-            int trackCount,
-            IReadOnlyList<Guid>? coverTrackIds = null)
-        {
-            return album switch
-            {
-                ExternalAlbum externalAlbum => ExternalAlbumApplicationResponse.FromEntity(externalAlbum, trackCount, coverTrackIds),
-                UserAlbum userAlbum => FromEntity(userAlbum, trackCount, coverTrackIds),
-                _ => throw new NotSupportedException($"Unsupported album entity type '{album.GetType().Name}'.")
-            };
-        }
     }
 }

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

@@ -1,22 +1,7 @@
-using Musify.Application.Contracts;
-using Musify.Domain.ValueObjects;
-
 namespace Musify.Application.Albums.Responses
 {
-    /// <summary>One item of a combined local/external album listing. Exactly one of
-    /// <see cref="Album"/> or <see cref="YouTubeAlbum"/> is populated: <see cref="Album"/> for
-    /// anything already in the catalog (locally created albums and external albums materialized
-    /// earlier), <see cref="YouTubeAlbum"/> for a live external search hit that hasn't been
-    /// materialized yet, so it has no album id.</summary>
-    public record AlbumSearchItemResponse(
-        TrackSource Source,
-        AlbumApplicationResponse? Album,
-        YouTubeAlbumResult? YouTubeAlbum)
+    public record AlbumSearchItemResponse(AlbumApplicationResponse Album)
     {
-        public static AlbumSearchItemResponse FromAlbum(AlbumApplicationResponse album) =>
-            new(album is ExternalAlbumApplicationResponse ? TrackSource.YouTube : TrackSource.Local, album, null);
-
-        public static AlbumSearchItemResponse FromYouTubeAlbum(YouTubeAlbumResult album) =>
-            new(TrackSource.YouTube, null, album);
+        public static AlbumSearchItemResponse FromAlbum(AlbumApplicationResponse album) => new(album);
     }
 }

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

@@ -1,11 +1,6 @@
 namespace Musify.Application.Albums.Responses
 {
-    /// <summary>Result of a combined albums listing/search: a page of local catalog albums
-    /// (user-created and previously materialized external albums), plus, when a search term was
-    /// given, live external hits appended after them. Pagination metadata (<see cref="PageNumber"/>,
-    /// <see cref="PageSize"/>, <see cref="PageCount"/>, <see cref="TotalItemCount"/>) describes only
-    /// the local page — the external source has no stable total, so its continuation is tracked
-    /// separately via <see cref="NextYoutubeContinuationToken"/>.</summary>
+    /// <summary>A page of the user's catalog albums (their own).</summary>
     public record AlbumsSearchResponse(
         IReadOnlyList<AlbumSearchItemResponse> Items,
         int PageNumber,
@@ -13,26 +8,5 @@ namespace Musify.Application.Albums.Responses
         int PageCount,
         int TotalItemCount,
         bool HasPreviousPage,
-        bool HasNextLocalPage,
-        string? NextYoutubeContinuationToken,
-        bool YoutubeUnavailable,
-        bool HasNextPage)
-    {
-        // HasNextPage is a real field (not a computed property) so it shows up as a required member
-        // of the generated OpenAPI schema, same as every other field here — a get-only property added
-        // outside the primary constructor gets reflected as optional instead, which is never true here.
-        public static AlbumsSearchResponse Create(
-            IReadOnlyList<AlbumSearchItemResponse> items,
-            int pageNumber,
-            int pageSize,
-            int pageCount,
-            int totalItemCount,
-            bool hasPreviousPage,
-            bool hasNextLocalPage,
-            string? nextYoutubeContinuationToken,
-            bool youtubeUnavailable) =>
-            new(items, pageNumber, pageSize, pageCount, totalItemCount, hasPreviousPage, hasNextLocalPage,
-                nextYoutubeContinuationToken, youtubeUnavailable,
-                HasNextPage: hasNextLocalPage || !string.IsNullOrEmpty(nextYoutubeContinuationToken));
-    }
+        bool HasNextPage);
 }

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

@@ -1,47 +0,0 @@
-using Musify.Domain.Entities;
-
-namespace Musify.Application.Albums.Responses
-{
-    public record ExternalAlbumApplicationResponse(
-        Guid Id,
-        string Title,
-        string? Description,
-        int? ReleaseYear,
-        long OwnerUserId,
-        int TrackCount,
-        string? SmallImageKeyName,
-        string? MediumImageKeyName,
-        string? LargeImageKeyName,
-        DateTime CreatedAt,
-        DateTime UpdatedAt,
-        IReadOnlyList<Guid> CoverTrackIds,
-        string ExternalId,
-        string? ThumbnailUrl)
-        : AlbumApplicationResponse(
-            Id, Title, Description, ReleaseYear, OwnerUserId, TrackCount,
-            SmallImageKeyName, MediumImageKeyName, LargeImageKeyName,
-            CreatedAt, UpdatedAt, CoverTrackIds)
-    {
-        public static ExternalAlbumApplicationResponse FromEntity(
-            ExternalAlbum album,
-            int trackCount,
-            IReadOnlyList<Guid>? coverTrackIds = null)
-        {
-            return new ExternalAlbumApplicationResponse(
-                album.Id,
-                album.Title,
-                album.Description,
-                album.ReleaseYear,
-                0,
-                trackCount,
-                album.Pictures?.SmallName,
-                album.Pictures?.MediumName,
-                album.Pictures?.LargeName,
-                album.CreatedAt,
-                album.UpdatedAt,
-                coverTrackIds ?? [],
-                album.ExternalId,
-                album.ThumbnailUrl);
-        }
-    }
-}

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

@@ -34,7 +34,7 @@ namespace Musify.Application.Albums
     {
         public async ValueTask<ErrorOr<AlbumApplicationResponse>> Handle(UpdateAlbumCommand request, CancellationToken cancellationToken)
         {
-            var album = await database.UserAlbums
+            var album = await database.Albums
                 .SingleOrDefaultAsync(a => a.Id == request.AlbumId, cancellationToken);
             if (album is null)
             {
@@ -77,7 +77,7 @@ namespace Musify.Application.Albums
                 finalPictureKey = albumConfiguration.Routes.BuildOriginalPicturePath(request.UserId, pictureIntent.ObjectName);
             }
 
-            database.UserAlbums.Update(album);
+            database.Albums.Update(album);
 
             if (pictureIntent != null && finalPictureKey != null)
             {