fix: playlist being empty(this time is true)

Author: Heropowwa

composeApp/src/commonMain/kotlin/paige/navic/data/database/dao/SongDao.kt

@@ -5,6 +5,7 @@ import androidx.room3.Insert
 import androidx.room3.OnConflictStrategy
 import androidx.room3.Query
 import androidx.room3.Transaction
+import androidx.room3.Upsert
 import paige.navic.data.database.entities.SongEntity
 import paige.navic.util.core.Logger
 
@@ -13,10 +14,10 @@ interface SongDao {
 	@Query("SELECT * FROM SongEntity WHERE songId = :songId LIMIT 1")
 	suspend fun getSongById(songId: String): SongEntity?
 
-	@Insert(onConflict = OnConflictStrategy.REPLACE)
+	@Upsert
 	suspend fun insertSong(song: SongEntity)
 
-	@Insert(onConflict = OnConflictStrategy.REPLACE)
+	@Upsert
 	suspend fun insertSongs(songs: List<SongEntity>)
 
 	@Insert(onConflict = OnConflictStrategy.IGNORE)

composeApp/src/commonMain/kotlin/paige/navic/domain/repositories/DbRepository.kt

@@ -103,11 +103,17 @@ class DbRepository(
 		progressCallback(0.07f, Res.string.info_syncing_playlists)
 		val playlists = syncPlaylists().getOrThrow()
 
-		syncLibrarySongs { localProgress, message ->
+		val validAlbumIds = mutableSetOf<String>()
+		val validSongIds = mutableSetOf<String>()
+
+		val libraryResult = syncLibrarySongs { localProgress, message ->
 			val globalProgress = 0.10f + (localProgress * 0.65f)
 			progressCallback(globalProgress, message)
 		}.getOrThrow()
 
+		validAlbumIds.addAll(libraryResult.first)
+		validSongIds.addAll(libraryResult.second)
+
 		val totalPlaylists = playlists.size
 		if (totalPlaylists > 0) {
 			val completedPlaylists = AtomicInt(0)
@@ -116,7 +122,9 @@ class DbRepository(
 				playlists.map { playlist ->
 					async {
 						concurrentRequestLimit.withPermit {
-							syncPlaylistSongs(playlist.playlistId).getOrThrow()
+							val playlistSongIds = syncPlaylistSongs(playlist.playlistId).getOrThrow()
+							validSongIds.addAll(playlistSongIds)
+
 							val done = completedPlaylists.incrementAndGet()
 							val globalProgress = 0.75f + (0.25f * (done.toFloat() / totalPlaylists))
 							progressCallback(globalProgress, Res.string.info_syncing_playlists)
@@ -126,12 +134,15 @@ class DbRepository(
 			}
 		}
 
+		albumDao.deleteObsoleteAlbums(validAlbumIds)
+		songDao.deleteObsoleteSongs(validSongIds)
+
 		progressCallback(1.0f, Res.string.info_syncing_finished)
 	}
 
 	suspend fun syncLibrarySongs(
 		onProgress: (Float, StringResource) -> Unit = { _, _ -> }
-	): Result<Int> = runDbOp {
+	): Result<Pair<Set<String>, Set<String>>> = runDbOp {
 		val pageSize = 500
 		var offset = 0
 		val allAlbumSummaries = mutableListOf<ApiAlbum>()
@@ -146,7 +157,7 @@ class DbRepository(
 			offset += pageSize
 		}
 
-		if (allAlbumSummaries.isEmpty()) return@runDbOp 0
+		if (allAlbumSummaries.isEmpty()) return@runDbOp emptySet<String>() to emptySet()
 
 		val totalAlbums = allAlbumSummaries.size
 		val completedAlbums = AtomicInt(0)
@@ -230,16 +241,13 @@ class DbRepository(
 			}
 		}
 
-		albumDao.deleteObsoleteAlbums(allValidAlbumIds)
-		songDao.deleteObsoleteSongs(allValidSongIds)
-
 		Logger.i(
 			"DbRepository",
 			"- Songs Synced: $totalAlbums albums, $finalSongsSynced songs"
 		)
 
 		onProgress(1.0f, Res.string.info_syncing_saved)
-		finalSongsSynced
+		allValidAlbumIds to allValidSongIds
 	}
 
 	suspend fun syncPlaylists(): Result<List<PlaylistEntity>> = runDbOp {
@@ -258,7 +266,7 @@ class DbRepository(
 		playlistEntities
 	}
 
-	suspend fun syncPlaylistSongs(playlistId: String): Result<Int> = runDbOp {
+	suspend fun syncPlaylistSongs(playlistId: String): Result<Set<String>> = runDbOp {
 		val playlist = try {
 			sessionManager.api.getPlaylist(playlistId)
 		} catch (e: Exception) {
@@ -268,14 +276,13 @@ class DbRepository(
 					"could not deserialize playlist $playlistId; skipping it",
 					e
 				)
-				return@runDbOp 0
+				return@runDbOp emptySet<String>()
 			} else {
 				throw e
 			}
 		}
 		val songEntities = playlist.songs.map { it.toEntity() }
-
-		playlistDao.deletePlaylistSongCrossRefs(playlistId)
+		val songIds = songEntities.map { it.songId }.toSet()
 
 		if (songEntities.isNotEmpty()) {
 			songEntities.chunked(dbChunkSize).forEach { chunk ->
@@ -286,13 +293,13 @@ class DbRepository(
 				PlaylistSongCrossRef(playlistId = playlistId, songId = it.songId, position = index)
 			}
 
-			crossRefs.chunked(dbChunkSize).forEach { chunk ->
-				playlistDao.insertPlaylistSongCrossRefs(chunk)
-			}
+			playlistDao.replacePlaylistSongs(playlistId, crossRefs)
+		} else {
+			playlistDao.deletePlaylistSongCrossRefs(playlistId)
 		}
 
 		Logger.i("DbRepository", "- Playlist [$playlistId] synced: ${songEntities.size} songs")
-		songEntities.size
+		songIds
 	}
 
 	suspend fun syncGenres(): Result<Unit> = runDbOp {