A lot of changes

backend/Musify.Application/PlayLists/AddTrackToPlayList.cs

@@ -49,10 +49,13 @@ namespace Musify.Application.PlayLists
                 return Error.Conflict(description: "Track is already in the playlist.");
             }
 
-            var nextPosition = await database.PlayListHasTracks
-                .Where(plt => plt.PlayListId == request.PlayListId)
-                .Select(plt => (int?)plt.Position)
-                .MaxAsync(cancellationToken) + 1 ?? 0;
+            var playListTracksQuery = database.PlayListHasTracks
+                .Where(plt => plt.PlayListId == request.PlayListId);
+
+            var hasTracks = await playListTracksQuery.AnyAsync(cancellationToken);
+            var nextPosition = hasTracks
+                ? await playListTracksQuery.MaxAsync(plt => plt.Position, cancellationToken) + 1
+                : 0;
 
             await database.PlayListHasTracks.AddAsync(new PlayListHasTrack
             {

backend/Musify.Application/PlayLists/AddYouTubeTrackToPlayList.cs

@@ -51,7 +51,7 @@ namespace Musify.Application.PlayLists
 
             var track = provisionResult.Value.Track;
 
-            var failed = track.Audio.TranscodeStatus == ProcessingStatus.Failed;
+            var failed = track.Audio.IsFailed;
             var neverQueued = !track.Audio.DownloadRequested && !track.Audio.IsProcessed;
             if (failed || neverQueued)
             {
@@ -82,10 +82,13 @@ namespace Musify.Application.PlayLists
                 return Error.Conflict(description: "Track is already in the playlist.");
             }
 
-            var nextPosition = await database.PlayListHasTracks
-                .Where(plt => plt.PlayListId == request.PlayListId)
-                .Select(plt => (int?)plt.Position)
-                .MaxAsync(cancellationToken) + 1 ?? 0;
+            var playListTracksQuery = database.PlayListHasTracks
+                .Where(plt => plt.PlayListId == request.PlayListId);
+
+            var hasTracks = await playListTracksQuery.AnyAsync(cancellationToken);
+            var nextPosition = hasTracks
+                ? await playListTracksQuery.MaxAsync(plt => plt.Position, cancellationToken) + 1
+                : 0;
 
             await database.PlayListHasTracks.AddAsync(new PlayListHasTrack
             {

backend/Musify.Application/PlayLists/CreatePlayList.cs

@@ -8,6 +8,7 @@ using Musify.Application.Events;
 using Musify.Application.PlayLists.Responses;
 using Musify.Application.Services;
 using Musify.Domain.Entities;
+using Musify.Domain.ValueObjects;
 using Musify.Application.Contracts;
 
 namespace Musify.Application.PlayLists
@@ -65,10 +66,13 @@ namespace Musify.Application.PlayLists
                 Name = request.Name,
                 NormalizedName = request.Name.Trim().ToUpperInvariant(),
                 Description = request.Description,
-                OriginalPictureName = originalPictureName,
-                SmallPictureName = playListConfiguration.Routes.PresetSmallPicture,
-                MediumPictureName = playListConfiguration.Routes.PresetMediumPicture,
-                LargePictureName = playListConfiguration.Routes.PresetLargePicture
+                Pictures = new PlayListPictures
+                {
+                    OriginalName = originalPictureName,
+                    SmallName = playListConfiguration.Routes.PresetSmallPicture,
+                    MediumName = playListConfiguration.Routes.PresetMediumPicture,
+                    LargeName = playListConfiguration.Routes.PresetLargePicture
+                }
             };
 
             await database.PlayLists.AddAsync(playList, cancellationToken);

backend/Musify.Application/PlayLists/GetPlayListCover.cs

@@ -22,7 +22,7 @@ namespace Musify.Application.PlayLists
         {
             var playList = await database.PlayLists.AsNoTracking()
                 .Where(p => p.Id == request.PlayListId)
-                .Select(p => new { p.SmallPictureName, p.MediumPictureName, p.LargePictureName })
+                .Select(p => new { p.Pictures.SmallName, p.Pictures.MediumName, p.Pictures.LargeName })
                 .SingleOrDefaultAsync(cancellationToken);
 
             if (playList == null)
@@ -31,9 +31,9 @@ namespace Musify.Application.PlayLists
             var routes = playListConfiguration.Routes;
             var (name, key, presetName) = request.Size.ToLowerInvariant() switch
             {
-                "small" => (playList.SmallPictureName, BuildKey(routes.BuildSmallPicturePath, playList.SmallPictureName), routes.PresetSmallPicture),
-                "large" => (playList.LargePictureName, BuildKey(routes.BuildLargePicturePath, playList.LargePictureName), routes.PresetLargePicture),
-                _ => (playList.MediumPictureName, BuildKey(routes.BuildMediumPicturePath, playList.MediumPictureName), routes.PresetMediumPicture)
+                "small" => (playList.SmallName, BuildKey(routes.BuildSmallPicturePath, playList.SmallName), routes.PresetSmallPicture),
+                "large" => (playList.LargeName, BuildKey(routes.BuildLargePicturePath, playList.LargeName), routes.PresetLargePicture),
+                _ => (playList.MediumName, BuildKey(routes.BuildMediumPicturePath, playList.MediumName), routes.PresetMediumPicture)
             };
 
             if (string.IsNullOrEmpty(name) || string.IsNullOrEmpty(key) || name == presetName)

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

@@ -18,9 +18,9 @@ namespace Musify.Application.PlayLists.Responses
                 playList.Id,
                 playList.Name,
                 playList.Description,
-                playList.SmallPictureName,
-                playList.MediumPictureName,
-                playList.LargePictureName,
+                playList.Pictures.SmallName,
+                playList.Pictures.MediumName,
+                playList.Pictures.LargeName,
                 playList.CreatedAt,
                 playList.UpdatedAt);
         }

backend/Musify.Application/PlayLists/UpdatePlayList.cs

@@ -68,7 +68,7 @@ namespace Musify.Application.PlayLists
                     return validation.Errors;
 
                 pictureIntent = validation.Value;
-                playListEntity.OriginalPictureName = pictureIntent.ObjectName;
+                playListEntity.Pictures.OriginalName = pictureIntent.ObjectName;
                 finalPictureKey = playListConfiguration.Routes.BuildOriginalPicturePath(request.UserId, pictureIntent.ObjectName);
             }
 

backend/Musify.Application/Services/UploadIntentValidator.cs

@@ -45,10 +45,10 @@ public sealed class UploadIntentValidator(
         if (intent is null || intent.UserId != userId)
             return Error.NotFound(description: "Upload intent not found or not accessible.");
 
-        if (intent.Status == UploadIntentStatus.Consumed)
+        if (intent.IsConsumed)
             return Error.Conflict(description: "Upload intent has already been consumed.");
 
-        if (intent.Status == UploadIntentStatus.Expired || intent.ExpiresAt < DateTime.UtcNow)
+        if (intent.IsExpired)
             return Error.Validation(description: "Upload intent has expired.");
 
         var metadata = await storageService.HeadObjectAsync(intent.Bucket, intent.Key, cancellationToken);

backend/Musify.Application/Services/YouTubeTrackProvisioner.cs

@@ -50,7 +50,7 @@ public sealed class YouTubeTrackProvisioner(
             NormalizedTitle = title.ToUpperInvariant(),
             Source = TrackSource.YouTube,
             ExternalId = videoId,
-            Duration = song.DurationSeconds,
+            DurationSeconds = song.DurationSeconds,
             Pictures = new TrackPictures
             {
                 SmallName = trackConfiguration.Routes.PresetSmallPicture,

backend/Musify.Application/Tracks/DeleteTrack.cs

@@ -34,8 +34,7 @@ namespace Musify.Application.Tracks
                 return Error.Unauthorized();
             }
 
-            if (track.Audio.TranscodeStatus == ProcessingStatus.Processing
-                || track.Audio.TranscodeStatus == ProcessingStatus.Pending)
+            if (track.Audio.IsInProgress)
             {
                 logger.LogWarning("Track {TrackId} is currently being processed and cannot be deleted", request.TrackId);
                 return Error.Conflict(description: "Track is currently being processed and cannot be deleted");

backend/Musify.Application/Tracks/GetTrackStream.cs

@@ -5,7 +5,6 @@ using Microsoft.Extensions.Logging;
 using Musify.Application.Contracts;
 using Musify.Application.Services;
 using Musify.Application.Tracks.Responses;
-using Musify.Domain.ValueObjects;
 
 namespace Musify.Application.Tracks
 {
@@ -22,20 +21,19 @@ namespace Musify.Application.Tracks
         {
             var track = await database.Tracks.AsNoTracking()
                 .Where(t => t.Id == request.TrackId)
-                .Select(t => new { t.Id, t.Audio.TranscodeStatus, t.Audio.FolderName } )
+                .Select(t => new { t.Id, t.Audio })
                 .SingleOrDefaultAsync(cancellationToken);
 
             if (track == null)
                 return Error.NotFound();
 
-            if (string.IsNullOrWhiteSpace(track.FolderName)
-                || track.TranscodeStatus != ProcessingStatus.Completed)
+            if (!track.Audio.IsProcessed)
             {
                 logger.LogInformation("Stream requested for track {TrackId} but audio is not ready", request.TrackId);
                 return Error.Conflict(description: "Track audio is not available for streaming yet.");
             }
 
-            var response = await streamIssuer.IssueAsync(track.Id, track.FolderName, request.UserId, cancellationToken);
+            var response = await streamIssuer.IssueAsync(track.Id, track.Audio.FolderName, request.UserId, cancellationToken);
 
             logger.LogInformation("Issued stream ticket for track {TrackId} to user {UserId}", request.TrackId, request.UserId);
 

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

@@ -25,7 +25,7 @@ namespace Musify.Application.Tracks.Responses
                 track.Source,
                 track.ExternalId,
                 track.Audio.TranscodeStatus,
-                track.Duration,
+                track.DurationSeconds,
                 listensCount,
                 track.OwnerUserId,
                 track.CreatedAt,

backend/Musify.Domain/Entities/PlayList.cs

@@ -26,23 +26,9 @@ namespace Musify.Domain.Entities
 
         [Required]
         [MaxLength(256)]
-        public required string Description { get; set; } = "No description was provided.";
+        public string Description { get; set; } = "No description was provided.";
 
-        [Required]
-        [MaxLength(64)]
-        public required string OriginalPictureName { get; set; }
-
-        [Required]
-        [MaxLength(64)]
-        public required string SmallPictureName { get; set; }
-
-        [Required]
-        [MaxLength(64)]
-        public required string MediumPictureName { get; set; }
-
-        [Required]
-        [MaxLength(64)]
-        public required string LargePictureName { get; set; }
+        public required PlayListPictures Pictures { get; set; }
 
         [Required]
         public LifeCycleStatus LifeCycleStatus { get; set; } = LifeCycleStatus.Active;

backend/Musify.Domain/Entities/Track.cs

@@ -20,7 +20,7 @@ namespace Musify.Domain.Entities
         public required string NormalizedTitle { get; set; }
 
         [Required]
-        public int Duration { get; set; }
+        public int DurationSeconds { get; set; }
 
         public long? OwnerUserId { get; set; }
 
@@ -43,7 +43,7 @@ namespace Musify.Domain.Entities
 
         public TrackAudio Audio { get; set; } = new();
 
-        [ForeignKey(nameof(OwnerUserId))]
+        [ForeignKey(nameof(OwnerUserId)) ]
         public User? Owner { get; set; }
 
         public ICollection<UserHasTrack> UserTracks { get; set; } = new List<UserHasTrack>();
@@ -53,5 +53,8 @@ namespace Musify.Domain.Entities
         public ICollection<ListeningHistory> ListeningHistories { get; set; } = new List<ListeningHistory>();
 
         public ICollection<TrackArtist> TrackArtists { get; set; } = new List<TrackArtist>();
+
+        [NotMapped]
+        public bool IsExternal => Source != TrackSource.Local;
     }
 }

backend/Musify.Domain/Entities/UploadIntent.cs

@@ -40,6 +40,12 @@ namespace Musify.Domain.Entities
         [Required]
         public DateTime CreatedAt { get; set; } = DateTime.UtcNow;
 
+        [NotMapped]
+        public bool IsConsumed => Status == UploadIntentStatus.Consumed;
+
+        [NotMapped]
+        public bool IsExpired => Status == UploadIntentStatus.Expired || ExpiresAt < DateTime.UtcNow;
+
         [ForeignKey(nameof(UserId)) ]
         public User User { get; set; } = null!;
     }

backend/Musify.Domain/ValueObjects/PlayListPictures.cs

@@ -0,0 +1,13 @@
+namespace Musify.Domain.ValueObjects
+{
+    public class PlayListPictures
+    {
+        public required string OriginalName { get; set; }
+
+        public required string SmallName { get; set; }
+
+        public required string MediumName { get; set; }
+
+        public required string LargeName { get; set; }
+    }
+}

backend/Musify.Domain/ValueObjects/TrackAudio.cs

@@ -19,5 +19,9 @@ namespace Musify.Domain.ValueObjects
 
         [MemberNotNullWhen(true, nameof(FolderName))]
         public bool IsProcessed => TranscodeStatus == ProcessingStatus.Completed;
+
+        public bool IsFailed => TranscodeStatus == ProcessingStatus.Failed;
+
+        public bool IsInProgress => TranscodeStatus is ProcessingStatus.Pending or ProcessingStatus.Processing;
     }
 }

backend/Musify.Infrastructure/MassTransit/Activities/Audio/UpdateTrackAudioActivity.cs

@@ -53,10 +53,10 @@ namespace Musify.Infrastructure.MassTransit.Activities.Audio
                 var log = new UpdateTrackAudioLog(
                     track.Id,
                     track.Audio.FolderName,
-                    track.Duration);
+                    track.DurationSeconds);
 
                 track.Audio.FolderName = Path.GetFileName(audioFolderKey);
-                track.Duration = durationSeconds;
+                track.DurationSeconds = durationSeconds;
                 track.Audio.TranscodeStatus = ProcessingStatus.Completed;
                 await database.SaveChangesAsync(executeContext.CancellationToken);
 
@@ -97,7 +97,7 @@ namespace Musify.Infrastructure.MassTransit.Activities.Audio
                     throw new InvalidOperationException($"Track with id {compensateContext.Log.TrackId} not found");
 
                 track.Audio.FolderName = compensateContext.Log.PreviousAudioFolderName;
-                track.Duration = compensateContext.Log.PreviousDuration;
+                track.DurationSeconds = compensateContext.Log.PreviousDurationSeconds;
                 track.Audio.TranscodeStatus = ProcessingStatus.Failed;
                 await database.SaveChangesAsync(compensateContext.CancellationToken);
 

backend/Musify.Infrastructure/MassTransit/Activities/Pictures/UpdatePlayListPictureActivity.cs

@@ -39,15 +39,15 @@ namespace Musify.Infrastructure.MassTransit.Activities.Pictures
 
                 var log = new UpdatePlayListPictureLog(
                     playList.Id,
-                    playList.OriginalPictureName,
-                    playList.SmallPictureName,
-                    playList.MediumPictureName,
-                    playList.LargePictureName);
+                    playList.Pictures.OriginalName,
+                    playList.Pictures.SmallName,
+                    playList.Pictures.MediumName,
+                    playList.Pictures.LargeName);
 
-                playList.OriginalPictureName = Path.GetFileName(executeContext.Arguments.OriginalPictureKey);
-                playList.SmallPictureName = Path.GetFileName(smallResizedVariable);
-                playList.MediumPictureName = Path.GetFileName(mediumResizedVariable);
-                playList.LargePictureName = Path.GetFileName(largeResizedVariable);
+                playList.Pictures.OriginalName = Path.GetFileName(executeContext.Arguments.OriginalPictureKey);
+                playList.Pictures.SmallName = Path.GetFileName(smallResizedVariable);
+                playList.Pictures.MediumName = Path.GetFileName(mediumResizedVariable);
+                playList.Pictures.LargeName = Path.GetFileName(largeResizedVariable);
 
                 database.PlayLists.Update(playList);
                 await database.SaveChangesAsync(executeContext.CancellationToken);
@@ -82,10 +82,10 @@ namespace Musify.Infrastructure.MassTransit.Activities.Pictures
                     return compensateContext.Compensated();
                 }
 
-                playList.OriginalPictureName = compensateContext.Log.PreviousOriginalPictureKey;
-                playList.SmallPictureName = compensateContext.Log.PreviousSmallPictureKey;
-                playList.MediumPictureName = compensateContext.Log.PreviousMediumPictureKey;
-                playList.LargePictureName = compensateContext.Log.PreviousLargePictureKey;
+                playList.Pictures.OriginalName = compensateContext.Log.PreviousOriginalPictureKey;
+                playList.Pictures.SmallName = compensateContext.Log.PreviousSmallPictureKey;
+                playList.Pictures.MediumName = compensateContext.Log.PreviousMediumPictureKey;
+                playList.Pictures.LargeName = compensateContext.Log.PreviousLargePictureKey;
 
                 database.PlayLists.Update(playList);
                 await database.SaveChangesAsync(compensateContext.CancellationToken);

backend/Musify.Infrastructure/MassTransit/Logs/UpdateTrackAudioLog.cs

@@ -3,5 +3,5 @@
     public record UpdateTrackAudioLog(
         Guid TrackId,
         string? PreviousAudioFolderName,
-        int PreviousDuration);
+        int PreviousDurationSeconds);
 }

backend/Musify.Infrastructure/MassTransit/RoutingSlip/Builders/DeletePlayListRoutingSlipBuilder.cs

@@ -42,44 +42,44 @@ namespace Musify.Infrastructure.MassTransit.RoutingSlip.Builders
                 var bucket = storageConfiguration.Bucket;
                 var routes = playListConfiguration.Routes;
 
-                if (playList.OriginalPictureName != routes.PresetOriginalPicture)
+                if (playList.Pictures.OriginalName != routes.PresetOriginalPicture)
                 {
                     routingSlipBuilder.AddActivity(
                         ActivityNames.RemovePlayListOriginalPicture,
                         EndpointHelper.BuildExecuteActivityUri(RemoveFileFromBucketActivity.ExecuteEndpointName),
                         new RemoveFileFromBucketArguments(
                             bucket,
-                            routes.BuildOriginalPicturePath(userId, playList.OriginalPictureName)));
+                            routes.BuildOriginalPicturePath(userId, playList.Pictures.OriginalName)));
                 }
 
-                if (playList.SmallPictureName != routes.PresetSmallPicture)
+                if (playList.Pictures.SmallName != routes.PresetSmallPicture)
                 {
                     routingSlipBuilder.AddActivity(
                         ActivityNames.RemovePlayListSmallPicture,
                         EndpointHelper.BuildExecuteActivityUri(RemoveFileFromBucketActivity.ExecuteEndpointName),
                         new RemoveFileFromBucketArguments(
                             bucket,
-                            routes.BuildSmallPicturePath(playList.SmallPictureName)));
+                            routes.BuildSmallPicturePath(playList.Pictures.SmallName)));
                 }
 
-                if (playList.MediumPictureName != routes.PresetMediumPicture)
+                if (playList.Pictures.MediumName != routes.PresetMediumPicture)
                 {
                     routingSlipBuilder.AddActivity(
                         ActivityNames.RemovePlayListMediumPicture,
                         EndpointHelper.BuildExecuteActivityUri(RemoveFileFromBucketActivity.ExecuteEndpointName),
                         new RemoveFileFromBucketArguments(
                             bucket,
-                            routes.BuildMediumPicturePath(playList.MediumPictureName)));
+                            routes.BuildMediumPicturePath(playList.Pictures.MediumName)));
                 }
 
-                if (playList.LargePictureName != routes.PresetLargePicture)
+                if (playList.Pictures.LargeName != routes.PresetLargePicture)
                 {
                     routingSlipBuilder.AddActivity(
                         ActivityNames.RemovePlayListLargePicture,
                         EndpointHelper.BuildExecuteActivityUri(RemoveFileFromBucketActivity.ExecuteEndpointName),
                         new RemoveFileFromBucketArguments(
                             bucket,
-                            routes.BuildLargePicturePath(playList.LargePictureName)));
+                            routes.BuildLargePicturePath(playList.Pictures.LargeName)));
                 }
             }
 

backend/Musify.Infrastructure/Persistence/Database.cs

@@ -96,6 +96,16 @@ namespace Musify.Infrastructure.Persistence
                 .IsUnique()
                 .HasFilter("\"ExternalId\" IS NULL AND \"UserId\" IS NULL");
 
+            modelBuilder.Entity<PlayList>()
+                .OwnsOne(playList => playList.Pictures, pictures =>
+                {
+                    pictures.Property(p => p.OriginalName).HasColumnName("OriginalPictureName").HasMaxLength(64);
+                    pictures.Property(p => p.SmallName).HasColumnName("SmallPictureName").HasMaxLength(64);
+                    pictures.Property(p => p.MediumName).HasColumnName("MediumPictureName").HasMaxLength(64);
+                    pictures.Property(p => p.LargeName).HasColumnName("LargePictureName").HasMaxLength(64);
+                });
+            modelBuilder.Entity<PlayList>().Navigation(playList => playList.Pictures).IsRequired();
+
             var playListProcessing = modelBuilder.Entity<PlayListProcessingState>();
             playListProcessing.HasKey(state => state.CorrelationId);
             playListProcessing.Property(state => state.CorrelationId).ValueGeneratedNever();

backend/Musify.Infrastructure/Persistence/Migrations/20260717164632_MovePlayListPicturesToOwnedType.Designer.cs

@@ -0,0 +1,885 @@
+// <auto-generated />
+using System;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using Musify.Infrastructure.Persistence;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+
+#nullable disable
+
+namespace Musify.Infrastructure.Persistence.Migrations
+{
+    [DbContext(typeof(Database))]
+    [Migration("20260717164632_MovePlayListPicturesToOwnedType")]
+    partial class MovePlayListPicturesToOwnedType
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "10.0.8")
+                .HasAnnotation("Relational:MaxIdentifierLength", 63);
+
+            NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
+
+            modelBuilder.Entity("MassTransit.EntityFrameworkCoreIntegration.InboxState", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
+
+                    b.Property<DateTime?>("Consumed")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<Guid>("ConsumerId")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime?>("Delivered")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime?>("ExpirationTime")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<long?>("LastSequenceNumber")
+                        .HasColumnType("bigint");
+
+                    b.Property<Guid>("LockId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("MessageId")
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("ReceiveCount")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime>("Received")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<byte[]>("RowVersion")
+                        .IsConcurrencyToken()
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("bytea");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Delivered");
+
+                    b.ToTable("InboxState");
+                });
+
+            modelBuilder.Entity("MassTransit.EntityFrameworkCoreIntegration.OutboxMessage", b =>
+                {
+                    b.Property<long>("SequenceNumber")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("SequenceNumber"));
+
+                    b.Property<string>("Body")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ContentType")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<Guid?>("ConversationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("CorrelationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("DestinationAddress")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<DateTime?>("EnqueueTime")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime?>("ExpirationTime")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("FaultAddress")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("Headers")
+                        .HasColumnType("text");
+
+                    b.Property<Guid?>("InboxConsumerId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("InboxMessageId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("InitiatorId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("MessageId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("MessageType")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<Guid?>("OutboxId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Properties")
+                        .HasColumnType("text");
+
+                    b.Property<Guid?>("RequestId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ResponseAddress")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<DateTime>("SentTime")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("SourceAddress")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.HasKey("SequenceNumber");
+
+                    b.HasIndex("EnqueueTime");
+
+                    b.HasIndex("ExpirationTime");
+
+                    b.HasIndex("OutboxId", "SequenceNumber")
+                        .IsUnique();
+
+                    b.HasIndex("InboxMessageId", "InboxConsumerId", "SequenceNumber")
+                        .IsUnique();
+
+                    b.ToTable("OutboxMessage");
+                });
+
+            modelBuilder.Entity("MassTransit.EntityFrameworkCoreIntegration.OutboxState", b =>
+                {
+                    b.Property<Guid>("OutboxId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime>("Created")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime?>("Delivered")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<long?>("LastSequenceNumber")
+                        .HasColumnType("bigint");
+
+                    b.Property<Guid>("LockId")
+                        .HasColumnType("uuid");
+
+                    b.Property<byte[]>("RowVersion")
+                        .IsConcurrencyToken()
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("bytea");
+
+                    b.HasKey("OutboxId");
+
+                    b.HasIndex("Created");
+
+                    b.ToTable("OutboxState");
+                });
+
+            modelBuilder.Entity("Musify.Domain.Entities.Artist", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("ExternalId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)");
+
+                    b.Property<string>("NormalizedName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)");
+
+                    b.Property<DateTime>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<long?>("UserId")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ExternalId")
+                        .IsUnique();
+
+                    b.HasIndex("NormalizedName")
+                        .IsUnique()
+                        .HasFilter("\"ExternalId\" IS NULL AND \"UserId\" IS NULL");
+
+                    b.HasIndex("UserId")
+                        .IsUnique();
+
+                    b.ToTable("Artists");
+                });
+
+            modelBuilder.Entity("Musify.Domain.Entities.ListeningHistory", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime>("ListenedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<Guid>("TrackId")
+                        .HasColumnType("uuid");
+
+                    b.Property<long>("UserId")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("TrackId");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("ListeningHistory");
+                });
+
+            modelBuilder.Entity("Musify.Domain.Entities.PlayList", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<int>("LifeCycleStatus")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("NormalizedName")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<DateTime>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<long>("UserId")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("PlayLists");
+                });
+
+            modelBuilder.Entity("Musify.Domain.Entities.PlayListHasTrack", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime>("AddedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<Guid>("PlayListId")
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("Position")
+                        .HasColumnType("integer");
+
+                    b.Property<Guid>("TrackId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("PlayListId");
+
+                    b.HasIndex("TrackId");
+
+                    b.ToTable("PlayListHasTrack");
+                });
+
+            modelBuilder.Entity("Musify.Domain.Entities.Track", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("Duration")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("ExternalId")
+                        .HasMaxLength(16)
+                        .HasColumnType("character varying(16)");
+
+                    b.Property<int>("LifeCycleStatus")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("NormalizedTitle")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<long?>("OwnerUserId")
+                        .HasColumnType("bigint");
+
+                    b.Property<int>("Source")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<DateTime>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("OwnerUserId");
+
+                    b.HasIndex("Source", "ExternalId")
+                        .IsUnique();
+
+                    b.ToTable("Tracks", t =>
+                        {
+                            t.HasCheckConstraint("CK_Tracks_OwnerUserId_Source", "(\"OwnerUserId\" IS NOT NULL) = (\"Source\" = 0)");
+                        });
+                });
+
+            modelBuilder.Entity("Musify.Domain.Entities.TrackArtist", b =>
+                {
+                    b.Property<Guid>("TrackId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("ArtistId")
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("Position")
+                        .HasColumnType("integer");
+
+                    b.HasKey("TrackId", "ArtistId");
+
+                    b.HasIndex("ArtistId");
+
+                    b.ToTable("TrackArtist");
+                });
+
+            modelBuilder.Entity("Musify.Domain.Entities.Upload", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Bucket")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ContentType")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreatedTime")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Key")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int>("State")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Upload");
+                });
+
+            modelBuilder.Entity("Musify.Domain.Entities.UploadIntent", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Bucket")
+                        .IsRequired()
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.Property<string>("ContentType")
+                        .IsRequired()
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<long?>("ExpectedSizeBytes")
+                        .HasColumnType("bigint");
+
+                    b.Property<DateTime>("ExpiresAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Key")
+                        .IsRequired()
+                        .HasMaxLength(512)
+                        .HasColumnType("character varying(512)");
+
+                    b.Property<string>("ObjectName")
+                        .IsRequired()
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.Property<int>("Purpose")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("Status")
+                        .HasColumnType("integer");
+
+                    b.Property<long>("UserId")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("UploadIntents");
+                });
+
+            modelBuilder.Entity("Musify.Domain.Entities.User", b =>
+                {
+                    b.Property<long>("Id")
+                        .HasColumnType("bigint");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("FirstName")
+                        .HasMaxLength(48)
+                        .HasColumnType("character varying(48)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(48)
+                        .HasColumnType("character varying(48)");
+
+                    b.Property<string>("NormalizedName")
+                        .IsRequired()
+                        .HasMaxLength(48)
+                        .HasColumnType("character varying(48)");
+
+                    b.Property<string>("ProfilePictureUrl")
+                        .HasMaxLength(2048)
+                        .HasColumnType("character varying(2048)");
+
+                    b.Property<string>("SecondName")
+                        .HasMaxLength(48)
+                        .HasColumnType("character varying(48)");
+
+                    b.Property<DateTime>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("User");
+                });
+
+            modelBuilder.Entity("Musify.Domain.Entities.UserHasTrack", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("TrackId")
+                        .HasColumnType("uuid");
+
+                    b.Property<long>("UserId")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("TrackId");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("UserHasTrack");
+                });
+
+            modelBuilder.Entity("Musify.Infrastructure.MassTransit.Sagas.PlayListProcessingState", b =>
+                {
+                    b.Property<Guid>("CorrelationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Bucket")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("CurrentState")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("PictureKey")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("CorrelationId");
+
+                    b.ToTable("PlayListProcessingState");
+                });
+
+            modelBuilder.Entity("Musify.Infrastructure.MassTransit.Sagas.TrackProcessingState", b =>
+                {
+                    b.Property<Guid>("CorrelationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("AudioKey")
+                        .HasColumnType("text");
+
+                    b.Property<bool>("AudioProcessed")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("Bucket")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("CurrentState")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("PictureKey")
+                        .HasColumnType("text");
+
+                    b.Property<bool>("PictureProcessed")
+                        .HasColumnType("boolean");
+
+                    b.Property<DateTime>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("CorrelationId");
+
+                    b.ToTable("TrackProcessingState");
+                });
+
+            modelBuilder.Entity("MassTransit.EntityFrameworkCoreIntegration.OutboxMessage", b =>
+                {
+                    b.HasOne("MassTransit.EntityFrameworkCoreIntegration.OutboxState", null)
+                        .WithMany()
+                        .HasForeignKey("OutboxId");
+
+                    b.HasOne("MassTransit.EntityFrameworkCoreIntegration.InboxState", null)
+                        .WithMany()
+                        .HasForeignKey("InboxMessageId", "InboxConsumerId")
+                        .HasPrincipalKey("MessageId", "ConsumerId");
+                });
+
+            modelBuilder.Entity("Musify.Domain.Entities.Artist", b =>
+                {
+                    b.HasOne("Musify.Domain.Entities.User", "User")
+                        .WithMany()
+                        .HasForeignKey("UserId");
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("Musify.Domain.Entities.ListeningHistory", b =>
+                {
+                    b.HasOne("Musify.Domain.Entities.Track", "Track")
+                        .WithMany("ListeningHistories")
+                        .HasForeignKey("TrackId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Musify.Domain.Entities.User", "User")
+                        .WithMany("ListeningHistories")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Track");
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("Musify.Domain.Entities.PlayList", b =>
+                {
+                    b.HasOne("Musify.Domain.Entities.User", "User")
+                        .WithMany("PlayLists")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.OwnsOne("Musify.Domain.ValueObjects.PlayListPictures", "Pictures", b1 =>
+                        {
+                            b1.Property<Guid>("PlayListId")
+                                .HasColumnType("uuid");
+
+                            b1.Property<string>("LargeName")
+                                .IsRequired()
+                                .HasMaxLength(64)
+                                .HasColumnType("character varying(64)")
+                                .HasColumnName("LargePictureName");
+
+                            b1.Property<string>("MediumName")
+                                .IsRequired()
+                                .HasMaxLength(64)
+                                .HasColumnType("character varying(64)")
+                                .HasColumnName("MediumPictureName");
+
+                            b1.Property<string>("OriginalName")
+                                .IsRequired()
+                                .HasMaxLength(64)
+                                .HasColumnType("character varying(64)")
+                                .HasColumnName("OriginalPictureName");
+
+                            b1.Property<string>("SmallName")
+                                .IsRequired()
+                                .HasMaxLength(64)
+                                .HasColumnType("character varying(64)")
+                                .HasColumnName("SmallPictureName");
+
+                            b1.HasKey("PlayListId");
+
+                            b1.ToTable("PlayLists");
+
+                            b1.WithOwner()
+                                .HasForeignKey("PlayListId");
+                        });
+
+                    b.Navigation("Pictures")
+                        .IsRequired();
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("Musify.Domain.Entities.PlayListHasTrack", b =>
+                {
+                    b.HasOne("Musify.Domain.Entities.PlayList", "PlayList")
+                        .WithMany("PlayListTracks")
+                        .HasForeignKey("PlayListId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Musify.Domain.Entities.Track", "Track")
+                        .WithMany("PlayListTracks")
+                        .HasForeignKey("TrackId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("PlayList");
+
+                    b.Navigation("Track");
+                });
+
+            modelBuilder.Entity("Musify.Domain.Entities.Track", b =>
+                {
+                    b.HasOne("Musify.Domain.Entities.User", "Owner")
+                        .WithMany()
+                        .HasForeignKey("OwnerUserId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.OwnsOne("Musify.Domain.ValueObjects.TrackAudio", "Audio", b1 =>
+                        {
+                            b1.Property<Guid>("TrackId")
+                                .HasColumnType("uuid");
+
+                            b1.Property<bool>("DownloadRequested")
+                                .HasColumnType("boolean")
+                                .HasColumnName("DownloadRequested");
+
+                            b1.Property<string>("FolderName")
+                                .HasMaxLength(64)
+                                .HasColumnType("character varying(64)")
+                                .HasColumnName("AudioFolderName");
+
+                            b1.Property<DateTime?>("LastRetryAt")
+                                .HasColumnType("timestamp with time zone")
+                                .HasColumnName("LastRetryAt");
+
+                            b1.Property<string>("OriginalName")
+                                .HasMaxLength(64)
+                                .HasColumnType("character varying(64)")
+                                .HasColumnName("OriginalAudioName");
+
+                            b1.Property<int>("RetryCount")
+                                .HasColumnType("integer")
+                                .HasColumnName("RetryCount");
+
+                            b1.Property<int>("TranscodeStatus")
+                                .HasColumnType("integer")
+                                .HasColumnName("AudioTranscodeProcessingStatus");
+
+                            b1.HasKey("TrackId");
+
+                            b1.ToTable("Tracks");
+
+                            b1.WithOwner()
+                                .HasForeignKey("TrackId");
+                        });
+
+                    b.OwnsOne("Musify.Domain.ValueObjects.TrackPictures", "Pictures", b1 =>
+                        {
+                            b1.Property<Guid>("TrackId")
+                                .HasColumnType("uuid");
+
+                            b1.Property<string>("LargeName")
+                                .HasMaxLength(64)
+                                .HasColumnType("character varying(64)")
+                                .HasColumnName("LargePictureName");
+
+                            b1.Property<string>("MediumName")
+                                .HasMaxLength(64)
+                                .HasColumnType("character varying(64)")
+                                .HasColumnName("MediumPictureName");
+
+                            b1.Property<string>("OriginalName")
+                                .HasMaxLength(64)
+                                .HasColumnType("character varying(64)")
+                                .HasColumnName("OriginalPictureName");
+
+                            b1.Property<int>("ProcessingStatus")
+                                .HasColumnType("integer")
+                                .HasColumnName("PicturesProcessingStatus");
+
+                            b1.Property<string>("SmallName")
+                                .HasMaxLength(64)
+                                .HasColumnType("character varying(64)")
+                                .HasColumnName("SmallPictureName");
+
+                            b1.HasKey("TrackId");
+
+                            b1.ToTable("Tracks");
+
+                            b1.WithOwner()
+                                .HasForeignKey("TrackId");
+                        });
+
+                    b.Navigation("Audio")
+                        .IsRequired();
+
+                    b.Navigation("Owner");
+
+                    b.Navigation("Pictures")
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Musify.Domain.Entities.TrackArtist", b =>
+                {
+                    b.HasOne("Musify.Domain.Entities.Artist", "Artist")
+                        .WithMany("TrackArtists")
+                        .HasForeignKey("ArtistId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Musify.Domain.Entities.Track", "Track")
+                        .WithMany("TrackArtists")
+                        .HasForeignKey("TrackId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Artist");
+
+                    b.Navigation("Track");
+                });
+
+            modelBuilder.Entity("Musify.Domain.Entities.UploadIntent", b =>
+                {
+                    b.HasOne("Musify.Domain.Entities.User", "User")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("Musify.Domain.Entities.UserHasTrack", b =>
+                {
+                    b.HasOne("Musify.Domain.Entities.Track", "Track")
+                        .WithMany("UserTracks")
+                        .HasForeignKey("TrackId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Musify.Domain.Entities.User", "User")
+                        .WithMany("UserTracks")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Track");
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("Musify.Domain.Entities.Artist", b =>
+                {
+                    b.Navigation("TrackArtists");
+                });
+
+            modelBuilder.Entity("Musify.Domain.Entities.PlayList", b =>
+                {
+                    b.Navigation("PlayListTracks");
+                });
+
+            modelBuilder.Entity("Musify.Domain.Entities.Track", b =>
+                {
+                    b.Navigation("ListeningHistories");
+
+                    b.Navigation("PlayListTracks");
+
+                    b.Navigation("TrackArtists");
+
+                    b.Navigation("UserTracks");
+                });
+
+            modelBuilder.Entity("Musify.Domain.Entities.User", b =>
+                {
+                    b.Navigation("ListeningHistories");
+
+                    b.Navigation("PlayLists");
+
+                    b.Navigation("UserTracks");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

backend/Musify.Infrastructure/Persistence/Migrations/20260717164632_MovePlayListPicturesToOwnedType.cs

@@ -0,0 +1,22 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace Musify.Infrastructure.Persistence.Migrations
+{
+    /// <inheritdoc />
+    public partial class MovePlayListPicturesToOwnedType : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+
+        }
+    }
+}

backend/Musify.Infrastructure/Persistence/Migrations/20260717164812_RenameTrackDurationToDurationSeconds.Designer.cs

@@ -0,0 +1,885 @@
+// <auto-generated />
+using System;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using Musify.Infrastructure.Persistence;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+
+#nullable disable
+
+namespace Musify.Infrastructure.Persistence.Migrations
+{
+    [DbContext(typeof(Database))]
+    [Migration("20260717164812_RenameTrackDurationToDurationSeconds")]
+    partial class RenameTrackDurationToDurationSeconds
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "10.0.8")
+                .HasAnnotation("Relational:MaxIdentifierLength", 63);
+
+            NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
+
+            modelBuilder.Entity("MassTransit.EntityFrameworkCoreIntegration.InboxState", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
+
+                    b.Property<DateTime?>("Consumed")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<Guid>("ConsumerId")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime?>("Delivered")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime?>("ExpirationTime")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<long?>("LastSequenceNumber")
+                        .HasColumnType("bigint");
+
+                    b.Property<Guid>("LockId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("MessageId")
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("ReceiveCount")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime>("Received")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<byte[]>("RowVersion")
+                        .IsConcurrencyToken()
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("bytea");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Delivered");
+
+                    b.ToTable("InboxState");
+                });
+
+            modelBuilder.Entity("MassTransit.EntityFrameworkCoreIntegration.OutboxMessage", b =>
+                {
+                    b.Property<long>("SequenceNumber")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("SequenceNumber"));
+
+                    b.Property<string>("Body")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ContentType")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<Guid?>("ConversationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("CorrelationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("DestinationAddress")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<DateTime?>("EnqueueTime")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime?>("ExpirationTime")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("FaultAddress")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("Headers")
+                        .HasColumnType("text");
+
+                    b.Property<Guid?>("InboxConsumerId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("InboxMessageId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("InitiatorId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("MessageId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("MessageType")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<Guid?>("OutboxId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Properties")
+                        .HasColumnType("text");
+
+                    b.Property<Guid?>("RequestId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ResponseAddress")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<DateTime>("SentTime")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("SourceAddress")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.HasKey("SequenceNumber");
+
+                    b.HasIndex("EnqueueTime");
+
+                    b.HasIndex("ExpirationTime");
+
+                    b.HasIndex("OutboxId", "SequenceNumber")
+                        .IsUnique();
+
+                    b.HasIndex("InboxMessageId", "InboxConsumerId", "SequenceNumber")
+                        .IsUnique();
+
+                    b.ToTable("OutboxMessage");
+                });
+
+            modelBuilder.Entity("MassTransit.EntityFrameworkCoreIntegration.OutboxState", b =>
+                {
+                    b.Property<Guid>("OutboxId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime>("Created")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime?>("Delivered")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<long?>("LastSequenceNumber")
+                        .HasColumnType("bigint");
+
+                    b.Property<Guid>("LockId")
+                        .HasColumnType("uuid");
+
+                    b.Property<byte[]>("RowVersion")
+                        .IsConcurrencyToken()
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("bytea");
+
+                    b.HasKey("OutboxId");
+
+                    b.HasIndex("Created");
+
+                    b.ToTable("OutboxState");
+                });
+
+            modelBuilder.Entity("Musify.Domain.Entities.Artist", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("ExternalId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)");
+
+                    b.Property<string>("NormalizedName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)");
+
+                    b.Property<DateTime>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<long?>("UserId")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ExternalId")
+                        .IsUnique();
+
+                    b.HasIndex("NormalizedName")
+                        .IsUnique()
+                        .HasFilter("\"ExternalId\" IS NULL AND \"UserId\" IS NULL");
+
+                    b.HasIndex("UserId")
+                        .IsUnique();
+
+                    b.ToTable("Artists");
+                });
+
+            modelBuilder.Entity("Musify.Domain.Entities.ListeningHistory", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime>("ListenedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<Guid>("TrackId")
+                        .HasColumnType("uuid");
+
+                    b.Property<long>("UserId")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("TrackId");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("ListeningHistory");
+                });
+
+            modelBuilder.Entity("Musify.Domain.Entities.PlayList", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<int>("LifeCycleStatus")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("NormalizedName")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<DateTime>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<long>("UserId")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("PlayLists");
+                });
+
+            modelBuilder.Entity("Musify.Domain.Entities.PlayListHasTrack", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime>("AddedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<Guid>("PlayListId")
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("Position")
+                        .HasColumnType("integer");
+
+                    b.Property<Guid>("TrackId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("PlayListId");
+
+                    b.HasIndex("TrackId");
+
+                    b.ToTable("PlayListHasTrack");
+                });
+
+            modelBuilder.Entity("Musify.Domain.Entities.Track", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("DurationSeconds")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("ExternalId")
+                        .HasMaxLength(16)
+                        .HasColumnType("character varying(16)");
+
+                    b.Property<int>("LifeCycleStatus")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("NormalizedTitle")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<long?>("OwnerUserId")
+                        .HasColumnType("bigint");
+
+                    b.Property<int>("Source")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<DateTime>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("OwnerUserId");
+
+                    b.HasIndex("Source", "ExternalId")
+                        .IsUnique();
+
+                    b.ToTable("Tracks", t =>
+                        {
+                            t.HasCheckConstraint("CK_Tracks_OwnerUserId_Source", "(\"OwnerUserId\" IS NOT NULL) = (\"Source\" = 0)");
+                        });
+                });
+
+            modelBuilder.Entity("Musify.Domain.Entities.TrackArtist", b =>
+                {
+                    b.Property<Guid>("TrackId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("ArtistId")
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("Position")
+                        .HasColumnType("integer");
+
+                    b.HasKey("TrackId", "ArtistId");
+
+                    b.HasIndex("ArtistId");
+
+                    b.ToTable("TrackArtist");
+                });
+
+            modelBuilder.Entity("Musify.Domain.Entities.Upload", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Bucket")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ContentType")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreatedTime")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Key")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int>("State")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Upload");
+                });
+
+            modelBuilder.Entity("Musify.Domain.Entities.UploadIntent", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Bucket")
+                        .IsRequired()
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.Property<string>("ContentType")
+                        .IsRequired()
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<long?>("ExpectedSizeBytes")
+                        .HasColumnType("bigint");
+
+                    b.Property<DateTime>("ExpiresAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Key")
+                        .IsRequired()
+                        .HasMaxLength(512)
+                        .HasColumnType("character varying(512)");
+
+                    b.Property<string>("ObjectName")
+                        .IsRequired()
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.Property<int>("Purpose")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("Status")
+                        .HasColumnType("integer");
+
+                    b.Property<long>("UserId")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("UploadIntents");
+                });
+
+            modelBuilder.Entity("Musify.Domain.Entities.User", b =>
+                {
+                    b.Property<long>("Id")
+                        .HasColumnType("bigint");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("FirstName")
+                        .HasMaxLength(48)
+                        .HasColumnType("character varying(48)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(48)
+                        .HasColumnType("character varying(48)");
+
+                    b.Property<string>("NormalizedName")
+                        .IsRequired()
+                        .HasMaxLength(48)
+                        .HasColumnType("character varying(48)");
+
+                    b.Property<string>("ProfilePictureUrl")
+                        .HasMaxLength(2048)
+                        .HasColumnType("character varying(2048)");
+
+                    b.Property<string>("SecondName")
+                        .HasMaxLength(48)
+                        .HasColumnType("character varying(48)");
+
+                    b.Property<DateTime>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("User");
+                });
+
+            modelBuilder.Entity("Musify.Domain.Entities.UserHasTrack", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("TrackId")
+                        .HasColumnType("uuid");
+
+                    b.Property<long>("UserId")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("TrackId");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("UserHasTrack");
+                });
+
+            modelBuilder.Entity("Musify.Infrastructure.MassTransit.Sagas.PlayListProcessingState", b =>
+                {
+                    b.Property<Guid>("CorrelationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Bucket")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("CurrentState")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("PictureKey")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("CorrelationId");
+
+                    b.ToTable("PlayListProcessingState");
+                });
+
+            modelBuilder.Entity("Musify.Infrastructure.MassTransit.Sagas.TrackProcessingState", b =>
+                {
+                    b.Property<Guid>("CorrelationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("AudioKey")
+                        .HasColumnType("text");
+
+                    b.Property<bool>("AudioProcessed")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("Bucket")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("CurrentState")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("PictureKey")
+                        .HasColumnType("text");
+
+                    b.Property<bool>("PictureProcessed")
+                        .HasColumnType("boolean");
+
+                    b.Property<DateTime>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("CorrelationId");
+
+                    b.ToTable("TrackProcessingState");
+                });
+
+            modelBuilder.Entity("MassTransit.EntityFrameworkCoreIntegration.OutboxMessage", b =>
+                {
+                    b.HasOne("MassTransit.EntityFrameworkCoreIntegration.OutboxState", null)
+                        .WithMany()
+                        .HasForeignKey("OutboxId");
+
+                    b.HasOne("MassTransit.EntityFrameworkCoreIntegration.InboxState", null)
+                        .WithMany()
+                        .HasForeignKey("InboxMessageId", "InboxConsumerId")
+                        .HasPrincipalKey("MessageId", "ConsumerId");
+                });
+
+            modelBuilder.Entity("Musify.Domain.Entities.Artist", b =>
+                {
+                    b.HasOne("Musify.Domain.Entities.User", "User")
+                        .WithMany()
+                        .HasForeignKey("UserId");
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("Musify.Domain.Entities.ListeningHistory", b =>
+                {
+                    b.HasOne("Musify.Domain.Entities.Track", "Track")
+                        .WithMany("ListeningHistories")
+                        .HasForeignKey("TrackId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Musify.Domain.Entities.User", "User")
+                        .WithMany("ListeningHistories")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Track");
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("Musify.Domain.Entities.PlayList", b =>
+                {
+                    b.HasOne("Musify.Domain.Entities.User", "User")
+                        .WithMany("PlayLists")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.OwnsOne("Musify.Domain.ValueObjects.PlayListPictures", "Pictures", b1 =>
+                        {
+                            b1.Property<Guid>("PlayListId")
+                                .HasColumnType("uuid");
+
+                            b1.Property<string>("LargeName")
+                                .IsRequired()
+                                .HasMaxLength(64)
+                                .HasColumnType("character varying(64)")
+                                .HasColumnName("LargePictureName");
+
+                            b1.Property<string>("MediumName")
+                                .IsRequired()
+                                .HasMaxLength(64)
+                                .HasColumnType("character varying(64)")
+                                .HasColumnName("MediumPictureName");
+
+                            b1.Property<string>("OriginalName")
+                                .IsRequired()
+                                .HasMaxLength(64)
+                                .HasColumnType("character varying(64)")
+                                .HasColumnName("OriginalPictureName");
+
+                            b1.Property<string>("SmallName")
+                                .IsRequired()
+                                .HasMaxLength(64)
+                                .HasColumnType("character varying(64)")
+                                .HasColumnName("SmallPictureName");
+
+                            b1.HasKey("PlayListId");
+
+                            b1.ToTable("PlayLists");
+
+                            b1.WithOwner()
+                                .HasForeignKey("PlayListId");
+                        });
+
+                    b.Navigation("Pictures")
+                        .IsRequired();
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("Musify.Domain.Entities.PlayListHasTrack", b =>
+                {
+                    b.HasOne("Musify.Domain.Entities.PlayList", "PlayList")
+                        .WithMany("PlayListTracks")
+                        .HasForeignKey("PlayListId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Musify.Domain.Entities.Track", "Track")
+                        .WithMany("PlayListTracks")
+                        .HasForeignKey("TrackId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("PlayList");
+
+                    b.Navigation("Track");
+                });
+
+            modelBuilder.Entity("Musify.Domain.Entities.Track", b =>
+                {
+                    b.HasOne("Musify.Domain.Entities.User", "Owner")
+                        .WithMany()
+                        .HasForeignKey("OwnerUserId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.OwnsOne("Musify.Domain.ValueObjects.TrackAudio", "Audio", b1 =>
+                        {
+                            b1.Property<Guid>("TrackId")
+                                .HasColumnType("uuid");
+
+                            b1.Property<bool>("DownloadRequested")
+                                .HasColumnType("boolean")
+                                .HasColumnName("DownloadRequested");
+
+                            b1.Property<string>("FolderName")
+                                .HasMaxLength(64)
+                                .HasColumnType("character varying(64)")
+                                .HasColumnName("AudioFolderName");
+
+                            b1.Property<DateTime?>("LastRetryAt")
+                                .HasColumnType("timestamp with time zone")
+                                .HasColumnName("LastRetryAt");
+
+                            b1.Property<string>("OriginalName")
+                                .HasMaxLength(64)
+                                .HasColumnType("character varying(64)")
+                                .HasColumnName("OriginalAudioName");
+
+                            b1.Property<int>("RetryCount")
+                                .HasColumnType("integer")
+                                .HasColumnName("RetryCount");
+
+                            b1.Property<int>("TranscodeStatus")
+                                .HasColumnType("integer")
+                                .HasColumnName("AudioTranscodeProcessingStatus");
+
+                            b1.HasKey("TrackId");
+
+                            b1.ToTable("Tracks");
+
+                            b1.WithOwner()
+                                .HasForeignKey("TrackId");
+                        });
+
+                    b.OwnsOne("Musify.Domain.ValueObjects.TrackPictures", "Pictures", b1 =>
+                        {
+                            b1.Property<Guid>("TrackId")
+                                .HasColumnType("uuid");
+
+                            b1.Property<string>("LargeName")
+                                .HasMaxLength(64)
+                                .HasColumnType("character varying(64)")
+                                .HasColumnName("LargePictureName");
+
+                            b1.Property<string>("MediumName")
+                                .HasMaxLength(64)
+                                .HasColumnType("character varying(64)")
+                                .HasColumnName("MediumPictureName");
+
+                            b1.Property<string>("OriginalName")
+                                .HasMaxLength(64)
+                                .HasColumnType("character varying(64)")
+                                .HasColumnName("OriginalPictureName");
+
+                            b1.Property<int>("ProcessingStatus")
+                                .HasColumnType("integer")
+                                .HasColumnName("PicturesProcessingStatus");
+
+                            b1.Property<string>("SmallName")
+                                .HasMaxLength(64)
+                                .HasColumnType("character varying(64)")
+                                .HasColumnName("SmallPictureName");
+
+                            b1.HasKey("TrackId");
+
+                            b1.ToTable("Tracks");
+
+                            b1.WithOwner()
+                                .HasForeignKey("TrackId");
+                        });
+
+                    b.Navigation("Audio")
+                        .IsRequired();
+
+                    b.Navigation("Owner");
+
+                    b.Navigation("Pictures")
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Musify.Domain.Entities.TrackArtist", b =>
+                {
+                    b.HasOne("Musify.Domain.Entities.Artist", "Artist")
+                        .WithMany("TrackArtists")
+                        .HasForeignKey("ArtistId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Musify.Domain.Entities.Track", "Track")
+                        .WithMany("TrackArtists")
+                        .HasForeignKey("TrackId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Artist");
+
+                    b.Navigation("Track");
+                });
+
+            modelBuilder.Entity("Musify.Domain.Entities.UploadIntent", b =>
+                {
+                    b.HasOne("Musify.Domain.Entities.User", "User")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("Musify.Domain.Entities.UserHasTrack", b =>
+                {
+                    b.HasOne("Musify.Domain.Entities.Track", "Track")
+                        .WithMany("UserTracks")
+                        .HasForeignKey("TrackId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Musify.Domain.Entities.User", "User")
+                        .WithMany("UserTracks")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Track");
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("Musify.Domain.Entities.Artist", b =>
+                {
+                    b.Navigation("TrackArtists");
+                });
+
+            modelBuilder.Entity("Musify.Domain.Entities.PlayList", b =>
+                {
+                    b.Navigation("PlayListTracks");
+                });
+
+            modelBuilder.Entity("Musify.Domain.Entities.Track", b =>
+                {
+                    b.Navigation("ListeningHistories");
+
+                    b.Navigation("PlayListTracks");
+
+                    b.Navigation("TrackArtists");
+
+                    b.Navigation("UserTracks");
+                });
+
+            modelBuilder.Entity("Musify.Domain.Entities.User", b =>
+                {
+                    b.Navigation("ListeningHistories");
+
+                    b.Navigation("PlayLists");
+
+                    b.Navigation("UserTracks");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

backend/Musify.Infrastructure/Persistence/Migrations/20260717164812_RenameTrackDurationToDurationSeconds.cs

@@ -0,0 +1,28 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace Musify.Infrastructure.Persistence.Migrations
+{
+    /// <inheritdoc />
+    public partial class RenameTrackDurationToDurationSeconds : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.RenameColumn(
+                name: "Duration",
+                table: "Tracks",
+                newName: "DurationSeconds");
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.RenameColumn(
+                name: "DurationSeconds",
+                table: "Tracks",
+                newName: "Duration");
+        }
+    }
+}

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

@@ -272,19 +272,9 @@ namespace Musify.Infrastructure.Persistence.Migrations
                         .HasMaxLength(256)
                         .HasColumnType("character varying(256)");
 
-                    b.Property<string>("LargePictureName")
-                        .IsRequired()
-                        .HasMaxLength(64)
-                        .HasColumnType("character varying(64)");
-
                     b.Property<int>("LifeCycleStatus")
                         .HasColumnType("integer");
 
-                    b.Property<string>("MediumPictureName")
-                        .IsRequired()
-                        .HasMaxLength(64)
-                        .HasColumnType("character varying(64)");
-
                     b.Property<string>("Name")
                         .IsRequired()
                         .HasMaxLength(50)
@@ -295,16 +285,6 @@ namespace Musify.Infrastructure.Persistence.Migrations
                         .HasMaxLength(50)
                         .HasColumnType("character varying(50)");
 
-                    b.Property<string>("OriginalPictureName")
-                        .IsRequired()
-                        .HasMaxLength(64)
-                        .HasColumnType("character varying(64)");
-
-                    b.Property<string>("SmallPictureName")
-                        .IsRequired()
-                        .HasMaxLength(64)
-                        .HasColumnType("character varying(64)");
-
                     b.Property<DateTime>("UpdatedAt")
                         .HasColumnType("timestamp with time zone");
 
@@ -351,66 +331,27 @@ namespace Musify.Infrastructure.Persistence.Migrations
                         .ValueGeneratedOnAdd()
                         .HasColumnType("uuid");
 
-                    b.Property<string>("AudioFolderName")
-                        .HasMaxLength(64)
-                        .HasColumnType("character varying(64)");
-
-                    b.Property<int>("AudioTranscodeProcessingStatus")
-                        .HasColumnType("integer");
-
                     b.Property<DateTime>("CreatedAt")
                         .HasColumnType("timestamp with time zone");
 
-                    b.Property<bool>("DownloadRequested")
-                        .HasColumnType("boolean");
-
-                    b.Property<int>("Duration")
+                    b.Property<int>("DurationSeconds")
                         .HasColumnType("integer");
 
                     b.Property<string>("ExternalId")
                         .HasMaxLength(16)
                         .HasColumnType("character varying(16)");
 
-                    b.Property<string>("LargePictureName")
-                        .HasMaxLength(64)
-                        .HasColumnType("character varying(64)");
-
-                    b.Property<DateTime?>("LastRetryAt")
-                        .HasColumnType("timestamp with time zone");
-
                     b.Property<int>("LifeCycleStatus")
                         .HasColumnType("integer");
 
-                    b.Property<string>("MediumPictureName")
-                        .HasMaxLength(64)
-                        .HasColumnType("character varying(64)");
-
                     b.Property<string>("NormalizedTitle")
                         .IsRequired()
                         .HasMaxLength(50)
                         .HasColumnType("character varying(50)");
 
-                    b.Property<string>("OriginalAudioName")
-                        .HasMaxLength(64)
-                        .HasColumnType("character varying(64)");
-
-                    b.Property<string>("OriginalPictureName")
-                        .HasMaxLength(64)
-                        .HasColumnType("character varying(64)");
-
                     b.Property<long?>("OwnerUserId")
                         .HasColumnType("bigint");
 
-                    b.Property<int>("PicturesProcessingStatus")
-                        .HasColumnType("integer");
-
-                    b.Property<int>("RetryCount")
-                        .HasColumnType("integer");
-
-                    b.Property<string>("SmallPictureName")
-                        .HasMaxLength(64)
-                        .HasColumnType("character varying(64)");
-
                     b.Property<int>("Source")
                         .HasColumnType("integer");
 
@@ -703,6 +644,46 @@ namespace Musify.Infrastructure.Persistence.Migrations
                         .OnDelete(DeleteBehavior.Cascade)
                         .IsRequired();
 
+                    b.OwnsOne("Musify.Domain.ValueObjects.PlayListPictures", "Pictures", b1 =>
+                        {
+                            b1.Property<Guid>("PlayListId")
+                                .HasColumnType("uuid");
+
+                            b1.Property<string>("LargeName")
+                                .IsRequired()
+                                .HasMaxLength(64)
+                                .HasColumnType("character varying(64)")
+                                .HasColumnName("LargePictureName");
+
+                            b1.Property<string>("MediumName")
+                                .IsRequired()
+                                .HasMaxLength(64)
+                                .HasColumnType("character varying(64)")
+                                .HasColumnName("MediumPictureName");
+
+                            b1.Property<string>("OriginalName")
+                                .IsRequired()
+                                .HasMaxLength(64)
+                                .HasColumnType("character varying(64)")
+                                .HasColumnName("OriginalPictureName");
+
+                            b1.Property<string>("SmallName")
+                                .IsRequired()
+                                .HasMaxLength(64)
+                                .HasColumnType("character varying(64)")
+                                .HasColumnName("SmallPictureName");
+
+                            b1.HasKey("PlayListId");
+
+                            b1.ToTable("PlayLists");
+
+                            b1.WithOwner()
+                                .HasForeignKey("PlayListId");
+                        });
+
+                    b.Navigation("Pictures")
+                        .IsRequired();
+
                     b.Navigation("User");
                 });
 
@@ -732,7 +713,89 @@ namespace Musify.Infrastructure.Persistence.Migrations
                         .HasForeignKey("OwnerUserId")
                         .OnDelete(DeleteBehavior.Restrict);
 
+                    b.OwnsOne("Musify.Domain.ValueObjects.TrackAudio", "Audio", b1 =>
+                        {
+                            b1.Property<Guid>("TrackId")
+                                .HasColumnType("uuid");
+
+                            b1.Property<bool>("DownloadRequested")
+                                .HasColumnType("boolean")
+                                .HasColumnName("DownloadRequested");
+
+                            b1.Property<string>("FolderName")
+                                .HasMaxLength(64)
+                                .HasColumnType("character varying(64)")
+                                .HasColumnName("AudioFolderName");
+
+                            b1.Property<DateTime?>("LastRetryAt")
+                                .HasColumnType("timestamp with time zone")
+                                .HasColumnName("LastRetryAt");
+
+                            b1.Property<string>("OriginalName")
+                                .HasMaxLength(64)
+                                .HasColumnType("character varying(64)")
+                                .HasColumnName("OriginalAudioName");
+
+                            b1.Property<int>("RetryCount")
+                                .HasColumnType("integer")
+                                .HasColumnName("RetryCount");
+
+                            b1.Property<int>("TranscodeStatus")
+                                .HasColumnType("integer")
+                                .HasColumnName("AudioTranscodeProcessingStatus");
+
+                            b1.HasKey("TrackId");
+
+                            b1.ToTable("Tracks");
+
+                            b1.WithOwner()
+                                .HasForeignKey("TrackId");
+                        });
+
+                    b.OwnsOne("Musify.Domain.ValueObjects.TrackPictures", "Pictures", b1 =>
+                        {
+                            b1.Property<Guid>("TrackId")
+                                .HasColumnType("uuid");
+
+                            b1.Property<string>("LargeName")
+                                .HasMaxLength(64)
+                                .HasColumnType("character varying(64)")
+                                .HasColumnName("LargePictureName");
+
+                            b1.Property<string>("MediumName")
+                                .HasMaxLength(64)
+                                .HasColumnType("character varying(64)")
+                                .HasColumnName("MediumPictureName");
+
+                            b1.Property<string>("OriginalName")
+                                .HasMaxLength(64)
+                                .HasColumnType("character varying(64)")
+                                .HasColumnName("OriginalPictureName");
+
+                            b1.Property<int>("ProcessingStatus")
+                                .HasColumnType("integer")
+                                .HasColumnName("PicturesProcessingStatus");
+
+                            b1.Property<string>("SmallName")
+                                .HasMaxLength(64)
+                                .HasColumnType("character varying(64)")
+                                .HasColumnName("SmallPictureName");
+
+                            b1.HasKey("TrackId");
+
+                            b1.ToTable("Tracks");
+
+                            b1.WithOwner()
+                                .HasForeignKey("TrackId");
+                        });
+
+                    b.Navigation("Audio")
+                        .IsRequired();
+
                     b.Navigation("Owner");
+
+                    b.Navigation("Pictures")
+                        .IsRequired();
                 });
 
             modelBuilder.Entity("Musify.Domain.Entities.TrackArtist", b =>

backend/Musify.Worker/Musify.Worker.csproj

@@ -6,7 +6,6 @@
 
   <ItemGroup>
     <PackageReference Include="AWSSDK.S3" />
-    <PackageReference Include="DispatchR.Mediator" />
     <PackageReference Include="MassTransit" />
     <PackageReference Include="MassTransit.RabbitMQ" />
     <PackageReference Include="Microsoft.EntityFrameworkCore" />