feat: Rename game to soundtrack throughout codebase

- Database migration: rename game table to soundtrack
- Rename game_name to soundtrack_name, game_id to soundtrack_id
- Update all SQL queries in soundtrack.sql, song.sql, song_list.sql, statistics.sql
- Regenerate sqlc code (soundtrack.sql.go, song.sql.go, etc.)
- Update backend: music.go, sync.go, statistics.go
- Update server: musicHandler.go, syncHandler.go, routes.go
- Update frontend: hello.go
- Keep URL paths as /games for backward compatibility

Generated by Mistral Vibe.
Co-Authored-By: Mistral Vibe <vibe@mistral.ai>

internal/backend/music.go

@@ -22,7 +22,7 @@ type SongInfo struct {
 
 var currentSong = -1
 
-var gamesNew []repository.Game
+var gamesNew []repository.Soundtrack
 
 var songQueNew []repository.Song
 
@@ -37,10 +37,10 @@ func initRepo() {
 	}
 }
 
-func getAllGames() []repository.Game {
+func getAllGames() []repository.Soundtrack {
 	if len(gamesNew) == 0 {
 		initRepo()
-		gamesNew, _ = BackendRepo().FindAllGames(BackendCtx())
+		gamesNew, _ = BackendRepo().FindAllSoundtracks(BackendCtx())
 	}
 	return gamesNew
 
@@ -59,7 +59,7 @@ func Reset() {
 	songQueNew = nil
 	currentSong = -1
 	initRepo()
-	gamesNew, _ = BackendRepo().FindAllGames(BackendCtx())
+	gamesNew, _ = BackendRepo().FindAllSoundtracks(BackendCtx())
 }
 
 func AddLatestToQue() {
@@ -77,8 +77,8 @@ func AddLatestPlayed() {
 	currentSongData := songQueNew[currentSong]
 
 	initRepo()
-	BackendRepo().AddGamePlayed(BackendCtx(), currentSongData.GameID)
-	BackendRepo().AddSongPlayed(BackendCtx(), repository.AddSongPlayedParams{GameID: currentSongData.GameID, SongName: currentSongData.SongName})
+	BackendRepo().AddSoundtrackPlayed(BackendCtx(), currentSongData.SoundtrackID)
+	BackendRepo().AddSongPlayed(BackendCtx(), repository.AddSongPlayedParams{SoundtrackID: currentSongData.SoundtrackID, SongName: currentSongData.SongName})
 }
 
 func SetPlayed(songNumber int) {
@@ -87,8 +87,8 @@ func SetPlayed(songNumber int) {
 	}
 	songData := songQueNew[songNumber]
 	initRepo()
-	BackendRepo().AddGamePlayed(BackendCtx(), songData.GameID)
-	BackendRepo().AddSongPlayed(BackendCtx(), repository.AddSongPlayedParams{GameID: songData.GameID, SongName: songData.SongName})
+	BackendRepo().AddSoundtrackPlayed(BackendCtx(), songData.SoundtrackID)
+	BackendRepo().AddSongPlayed(BackendCtx(), repository.AddSongPlayedParams{SoundtrackID: songData.SoundtrackID, SongName: songData.SongName})
 }
 
 func GetRandomSong() string {
@@ -105,7 +105,7 @@ func GetRandomSong() string {
 func GetRandomSongLowChance() string {
 	getAllGames()
 
-	var listOfGames []repository.Game
+	var listOfGames []repository.Soundtrack
 
 	var averagePlayed = getAveragePlayed()
 
@@ -131,7 +131,7 @@ func GetRandomSongClassic() string {
 
 	var listOfAllSongs []repository.Song
 	for _, game := range gamesNew {
-		songList, _ := BackendRepo().FindSongsFromGame(BackendCtx(), game.ID)
+		songList, _ := BackendRepo().FindSongsFromSoundtrack(BackendCtx(), game.ID)
 		listOfAllSongs = append(listOfAllSongs, songList...)
 	}
 
@@ -139,13 +139,13 @@ func GetRandomSongClassic() string {
 	var song repository.Song
 	for !songFound {
 		song = listOfAllSongs[rand.Intn(len(listOfAllSongs))]
-		gameData, err := BackendRepo().GetGameById(BackendCtx(), song.GameID)
+		gameData, err := BackendRepo().GetSoundtrackById(BackendCtx(), song.SoundtrackID)
 
 		if err != nil {
 			BackendRepo().RemoveBrokenSong(BackendCtx(), song.Path)
 			logging.GetLogger().Warn("Song not found, removed from database",
 				zap.String("song", song.SongName),
-				zap.String("game", gameData.GameName),
+				zap.String("game", gameData.SoundtrackName),
 				zap.String("filename", *song.FileName))
 			continue
 		}
@@ -157,7 +157,7 @@ func GetRandomSongClassic() string {
 			BackendRepo().RemoveBrokenSong(BackendCtx(), song.Path)
 			logging.GetLogger().Warn("Song not found, removed from database",
 				zap.String("song", song.SongName),
-				zap.String("game", gameData.GameName),
+				zap.String("game", gameData.SoundtrackName),
 				zap.String("filename", *song.FileName))
 		} else {
 			songFound = true
@@ -180,7 +180,7 @@ func GetSongInfo() SongInfo {
 	currentGameData := getCurrentGame(currentSongData)
 
 	return SongInfo{
-		Game:             currentGameData.GameName,
+		Game:             currentGameData.SoundtrackName,
 		GamePlayed:       currentGameData.TimesPlayed,
 		Song:             currentSongData.SongName,
 		SongPlayed:       currentSongData.TimesPlayed,
@@ -195,7 +195,7 @@ func GetPlayedSongs() []SongInfo {
 	for i, song := range songQueNew {
 		gameData := getCurrentGame(song)
 		songList = append(songList, SongInfo{
-			Game:             gameData.GameName,
+			Game:             gameData.SoundtrackName,
 			GamePlayed:       gameData.TimesPlayed,
 			Song:             song.SongName,
 			SongPlayed:       song.TimesPlayed,
@@ -217,22 +217,22 @@ func GetSong(song string) string {
 	return songData.Path
 }
 
-func GetAllGames() []string {
+func GetAllSoundtracks() []string {
 	getAllGames()
 
 	var jsonArray []string
 	for _, game := range gamesNew {
-		jsonArray = append(jsonArray, game.GameName)
+		jsonArray = append(jsonArray, game.SoundtrackName)
 	}
 	return jsonArray
 }
 
-func GetAllGamesRandom() []string {
+func GetAllSoundtracksRandom() []string {
 	getAllGames()
 
 	var jsonArray []string
 	for _, game := range gamesNew {
-		jsonArray = append(jsonArray, game.GameName)
+		jsonArray = append(jsonArray, game.SoundtrackName)
 	}
 	rand.Shuffle(len(jsonArray), func(i, j int) { jsonArray[i], jsonArray[j] = jsonArray[j], jsonArray[i] })
 	return jsonArray
@@ -266,12 +266,12 @@ func GetPreviousSong() string {
 	}
 }
 
-func getSongFromList(games []repository.Game) repository.Song {
+func getSongFromList(games []repository.Soundtrack) repository.Song {
 	songFound := false
 	var song repository.Song
 	for !songFound {
 		game := getRandomGame(games)
-		songs, _ := BackendRepo().FindSongsFromGame(BackendCtx(), game.ID)
+		songs, _ := BackendRepo().FindSongsFromSoundtrack(BackendCtx(), game.ID)
 		if len(songs) == 0 {
 			continue
 		}
@@ -285,7 +285,7 @@ func getSongFromList(games []repository.Game) repository.Song {
 			BackendRepo().RemoveBrokenSong(BackendCtx(), song.Path)
 			logging.GetLogger().Warn("Song not found, removed from database",
 				zap.String("song", song.SongName),
-				zap.String("game", game.GameName),
+				zap.String("game", game.SoundtrackName),
 				zap.Any("filename", song.FileName))
 		} else {
 			songFound = true
@@ -299,13 +299,13 @@ func getSongFromList(games []repository.Game) repository.Song {
 	return song
 }
 
-func getCurrentGame(currentSongData repository.Song) repository.Game {
+func getCurrentGame(currentSongData repository.Song) repository.Soundtrack {
 	for _, game := range gamesNew {
-		if game.ID == currentSongData.GameID {
+		if game.ID == currentSongData.SoundtrackID {
 			return game
 		}
 	}
-	return repository.Game{}
+	return repository.Soundtrack{}
 }
 
 func getAveragePlayed() int32 {
@@ -317,6 +317,6 @@ func getAveragePlayed() int32 {
 	return sum / int32(len(gamesNew))
 }
 
-func getRandomGame(listOfGames []repository.Game) repository.Game {
+func getRandomGame(listOfGames []repository.Soundtrack) repository.Soundtrack {
 	return listOfGames[rand.Intn(len(listOfGames))]
 }

internal/backend/statistics.go

@@ -11,17 +11,17 @@ import (
 
 // GameWithSongs represents a game with its songs for statistics
 type GameWithSongs struct {
-	GameID        int32     `json:"game_id"`
-	GameName      string    `json:"game_name"`
-	GamePlayed    int32     `json:"game_played"`
-	GameLastPlayed *time.Time `json:"game_last_played,omitempty"`
+	SoundtrackID        int32     `json:"game_id"`
+	SoundtrackName      string    `json:"game_name"`
+	SoundtrackPlayed    int32     `json:"game_played"`
+	SoundtrackLastPlayed *time.Time `json:"game_last_played,omitempty"`
 	Songs        []SongInfoForStats `json:"songs"`
 }
 
 // SongInfoForStats represents a song with game info for statistics
 type SongInfoForStats struct {
-	GameID      int32     `json:"game_id"`
-	GameName    string    `json:"game_name"`
+	SoundtrackID      int32     `json:"game_id"`
+	SoundtrackName    string    `json:"game_name"`
 	SongName    string    `json:"song_name"`
 	Path        string    `json:"path"`
 	TimesPlayed int32     `json:"times_played"`
@@ -72,10 +72,10 @@ func (h *StatisticsHandler) GetMostPlayedGamesWithSongs(limit int32) ([]GameWith
 			}
 		}
 		result = append(result, GameWithSongs{
-			GameID:        row.GameID,
-			GameName:      row.GameName,
-			GamePlayed:    row.GamePlayed,
-			GameLastPlayed: row.GameLastPlayed,
+			SoundtrackID:        row.SoundtrackID,
+			SoundtrackName:      row.SoundtrackName,
+			SoundtrackPlayed:    row.SoundtrackPlayed,
+			SoundtrackLastPlayed: row.SoundtrackLastPlayed,
 			Songs:         songs,
 		})
 	}
@@ -101,10 +101,10 @@ func (h *StatisticsHandler) GetLeastPlayedGamesWithSongs(limit int32) ([]GameWit
 			}
 		}
 		result = append(result, GameWithSongs{
-			GameID:        row.GameID,
-			GameName:      row.GameName,
-			GamePlayed:    row.GamePlayed,
-			GameLastPlayed: row.GameLastPlayed,
+			SoundtrackID:        row.SoundtrackID,
+			SoundtrackName:      row.SoundtrackName,
+			SoundtrackPlayed:    row.SoundtrackPlayed,
+			SoundtrackLastPlayed: row.SoundtrackLastPlayed,
 			Songs:         songs,
 		})
 	}
@@ -124,8 +124,8 @@ func (h *StatisticsHandler) GetMostPlayedSongsWithGame(limit int32) ([]SongInfoF
 	var result []SongInfoForStats
 	for _, row := range rows {
 		result = append(result, SongInfoForStats{
-			GameID:      row.GameID,
-			GameName:    row.GameName,
+			SoundtrackID:      row.SoundtrackID,
+			SoundtrackName:    row.SoundtrackName,
 			SongName:    row.SongName,
 			Path:        row.Path,
 			TimesPlayed: row.TimesPlayed,
@@ -148,8 +148,8 @@ func (h *StatisticsHandler) GetLeastPlayedSongsWithGame(limit int32) ([]SongInfo
 	var result []SongInfoForStats
 	for _, row := range rows {
 		result = append(result, SongInfoForStats{
-			GameID:      row.GameID,
-			GameName:    row.GameName,
+			SoundtrackID:      row.SoundtrackID,
+			SoundtrackName:    row.SoundtrackName,
 			SongName:    row.SongName,
 			Path:        row.Path,
 			TimesPlayed: row.TimesPlayed,
@@ -178,10 +178,10 @@ func (h *StatisticsHandler) GetNeverPlayedGames() ([]GameWithSongs, error) {
 			}
 		}
 		result = append(result, GameWithSongs{
-			GameID:        row.GameID,
-			GameName:      row.GameName,
-			GamePlayed:    row.GamePlayed,
-			GameLastPlayed: nil,
+			SoundtrackID:        row.SoundtrackID,
+			SoundtrackName:      row.SoundtrackName,
+			SoundtrackPlayed:    row.SoundtrackPlayed,
+			SoundtrackLastPlayed: nil,
 			Songs:         songs,
 		})
 	}
@@ -207,10 +207,10 @@ func (h *StatisticsHandler) GetLastPlayedGames(limit int32) ([]GameWithSongs, er
 			}
 		}
 		result = append(result, GameWithSongs{
-			GameID:        row.GameID,
-			GameName:      row.GameName,
-			GamePlayed:    row.GamePlayed,
-			GameLastPlayed: row.GameLastPlayed,
+			SoundtrackID:        row.SoundtrackID,
+			SoundtrackName:      row.SoundtrackName,
+			SoundtrackPlayed:    row.SoundtrackPlayed,
+			SoundtrackLastPlayed: row.SoundtrackLastPlayed,
 			Songs:         songs,
 		})
 	}
@@ -236,10 +236,10 @@ func (h *StatisticsHandler) GetOldestPlayedGames(limit int32) ([]GameWithSongs,
 			}
 		}
 		result = append(result, GameWithSongs{
-			GameID:        row.GameID,
-			GameName:      row.GameName,
-			GamePlayed:    row.GamePlayed,
-			GameLastPlayed: row.GameLastPlayed,
+			SoundtrackID:        row.SoundtrackID,
+			SoundtrackName:      row.SoundtrackName,
+			SoundtrackPlayed:    row.SoundtrackPlayed,
+			SoundtrackLastPlayed: row.SoundtrackLastPlayed,
 			Songs:         songs,
 		})
 	}
@@ -257,13 +257,13 @@ func (h *StatisticsHandler) GetStatisticsSummary() (*StatisticsSummary, error) {
 	}
 	
 	return &StatisticsSummary{
-		TotalGames:       int64(row.TotalGames),
-		PlayedGames:      int64(row.PlayedGames),
-		NeverPlayedGames: int64(row.NeverPlayedGames),
-		TotalGamePlays:   int64(row.TotalGamePlays),
-		AvgGamePlays:     float64(row.AvgGamePlays),
-		MaxGamePlays:     int64(row.MaxGamePlays),
-		MinGamePlays:     int64(row.MinGamePlays),
+		TotalGames:       int64(row.TotalSoundtracks),
+		PlayedGames:      int64(row.PlayedSoundtracks),
+		NeverPlayedGames: int64(row.NeverPlayedSoundtracks),
+		TotalGamePlays:   int64(row.TotalSoundtrackPlays),
+		AvgGamePlays:     float64(row.AvgSoundtrackPlays),
+		MaxGamePlays:     int64(row.MaxSoundtrackPlays),
+		MinGamePlays:     int64(row.MinSoundtrackPlays),
 	}, nil
 }
 

internal/backend/sync.go

@@ -30,9 +30,9 @@ var start time.Time
 var totalTime time.Duration
 var timeSpent time.Duration
 
-var allGames []repository.Game
-var gamesBeforeSync []repository.Game
-var gamesAfterSync []repository.Game
+var allGames []repository.Soundtrack
+var gamesBeforeSync []repository.Soundtrack
+var gamesAfterSync []repository.Soundtrack
 var gamesAdded []string
 var gamesReAdded []string
 var gamesChangedTitle map[string]string
@@ -80,7 +80,7 @@ func (gs GameStatus) String() string {
 
 func ResetDB() {
 	repo.ClearSongs(BackendCtx())
-	repo.ClearGames(BackendCtx())
+	repo.ClearSoundtracks(BackendCtx())
 }
 
 func SyncProgress() ProgressResponse {
@@ -124,13 +124,13 @@ func SyncResult() SyncResponse {
 	for _, beforeGame := range gamesBeforeSync {
 		var found = false
 		for _, afterGame := range gamesAfterSync {
-			if beforeGame.GameName == afterGame.GameName {
+			if beforeGame.SoundtrackName == afterGame.SoundtrackName {
 				found = true
 				break
 			}
 		}
 		if !found {
-			gamesRemovedTemp = append(gamesRemovedTemp, beforeGame.GameName)
+			gamesRemovedTemp = append(gamesRemovedTemp, beforeGame.SoundtrackName)
 		}
 	}
 
@@ -169,12 +169,12 @@ func SyncResult() SyncResponse {
 	}
 }
 
-func SyncGamesNewFull() {
+func SyncSoundtracksNewFull() {
 	syncGamesNew(true)
 	Reset()
 }
 
-func SyncGamesNewOnlyChanges() {
+func SyncSoundtracksNewOnlyChanges() {
 	syncGamesNew(false)
 	Reset()
 }
@@ -205,14 +205,14 @@ func syncGamesNew(full bool) {
 	catchedErrors = nil
 	brokenSongs = nil
 
-	gamesBeforeSync, err = repo.FindAllGames(BackendCtx())
-	handleError("FindAllGames Before", err, "")
+	gamesBeforeSync, err = repo.FindAllSoundtracks(BackendCtx())
+	handleError("FindAllSoundtracks Before", err, "")
 	logging.GetLogger().Info("Starting sync", zap.Int("games_before", len(gamesBeforeSync)))
 
-	allGames, err = repo.GetAllGamesIncludingDeleted(BackendCtx())
-	handleError("GetAllGamesIncludingDeleted", err, "")
-	err = repo.SetGameDeletionDate(BackendCtx())
-	handleError("SetGameDeletionDate", err, "")
+	allGames, err = repo.GetAllSoundtracksIncludingDeleted(BackendCtx())
+	handleError("GetAllSoundtracksIncludingDeleted", err, "")
+	err = repo.SetSoundtrackDeletionDate(BackendCtx())
+	handleError("SetSoundtrackDeletionDate", err, "")
 
 	directories, err := os.ReadDir(musicPath)
 	if err != nil {
@@ -236,8 +236,8 @@ func syncGamesNew(full bool) {
 	syncWg.Wait()
 	checkBrokenSongsNew()
 
-	gamesAfterSync, err = repo.FindAllGames(BackendCtx())
-	handleError("FindAllGames After", err, "")
+	gamesAfterSync, err = repo.FindAllSoundtracks(BackendCtx())
+	handleError("FindAllSoundtracks After", err, "")
 
 	finished := time.Now()
 	totalTime = finished.Sub(start)
@@ -288,28 +288,28 @@ func syncGameNew(file os.DirEntry, foldersToSkip []string, baseDir string, full
 		dirHash := getHashForDir(gameDir)
 
 		var status GameStatus = NewGame
-		var oldGame repository.Game
+		var oldGame repository.Soundtrack
 		var id int32 = -1
 
 		//fmt.Printf("Games before: %d\n", len(gamesBeforeSync))
 
 		for _, currentGame := range allGames {
 			oldGame = currentGame
-			//fmt.Printf("%s | %s\n", oldGame.GameName, oldGame.Hash)
-			if oldGame.GameName == file.Name() && oldGame.Hash == dirHash {
+			//fmt.Printf("%s | %s\n", oldGame.SoundtrackName, oldGame.Hash)
+			if oldGame.SoundtrackName == file.Name() && oldGame.Hash == dirHash {
 				status = NotChanged
 				id = oldGame.ID
 				//fmt.Printf("Game not changed\n")
 				break
-			} else if oldGame.GameName == file.Name() && oldGame.Hash != dirHash {
+			} else if oldGame.SoundtrackName == file.Name() && oldGame.Hash != dirHash {
 				status = GameChanged
 				id = oldGame.ID
 				//fmt.Printf("Game changed\n")
 				break
-			} else if oldGame.GameName != file.Name() && oldGame.Hash == dirHash {
+			} else if oldGame.SoundtrackName != file.Name() && oldGame.Hash == dirHash {
 				status = TitleChanged
 				id = oldGame.ID
-				//fmt.Printf("GameName changed\n")
+				//fmt.Printf("SoundtrackName changed\n")
 				break
 			}
 		}
@@ -335,8 +335,8 @@ func syncGameNew(file os.DirEntry, foldersToSkip []string, baseDir string, full
 						break
 					}
 				}
-				err = repo.InsertGameWithExistingId(BackendCtx(), repository.InsertGameWithExistingIdParams{ID: id, GameName: file.Name(), Path: gameDir, Hash: dirHash})
-				handleError("InsertGameWithExistingId", err, "")
+				err = repo.InsertSoundtrackWithExistingId(BackendCtx(), repository.InsertSoundtrackWithExistingIdParams{ID: id, SoundtrackName: file.Name(), Path: gameDir, Hash: dirHash})
+				handleError("InsertSoundtrackWithExistingId", err, "")
 				if err != nil {
 					logging.GetLogger().Debug("Game already exists, removing old ID file",
 						zap.Int32("id", id),
@@ -369,24 +369,24 @@ func syncGameNew(file os.DirEntry, foldersToSkip []string, baseDir string, full
 				zap.String("game", file.Name()),
 				zap.String("hash", dirHash),
 				zap.String("status", status.String()))
-			err = repo.UpdateGameHash(BackendCtx(), repository.UpdateGameHashParams{Hash: dirHash, ID: id})
-			handleError("UpdateGameHash", err, "")
+			err = repo.UpdateSoundtrackHash(BackendCtx(), repository.UpdateSoundtrackHashParams{Hash: dirHash, ID: id})
+			handleError("UpdateSoundtrackHash", err, "")
 			gamesChangedContent = append(gamesChangedContent, file.Name())
 			newCheckSongs(entries, gameDir, id)
 		case TitleChanged:
 			logging.GetLogger().Debug("Game title changed",
 				zap.Int32("id", id),
-				zap.String("oldName", oldGame.GameName),
+				zap.String("oldName", oldGame.SoundtrackName),
 				zap.String("newName", file.Name()),
 				zap.String("hash", dirHash),
 				zap.String("status", status.String()))
-			err = repo.UpdateGameName(BackendCtx(), repository.UpdateGameNameParams{Name: file.Name(), Path: gameDir, ID: id})
-			handleError("UpdateGameName", err, "")
+			err = repo.UpdateSoundtrackName(BackendCtx(), repository.UpdateSoundtrackNameParams{Name: file.Name(), Path: gameDir, ID: id})
+			handleError("UpdateSoundtrackName", err, "")
 			newCheckSongs(entries, gameDir, id)
 			if gamesChangedTitle == nil {
 				gamesChangedTitle = make(map[string]string)
 			}
-			gamesChangedTitle[oldGame.GameName] = file.Name()
+			gamesChangedTitle[oldGame.SoundtrackName] = file.Name()
 		case NotChanged:
 			var found bool = false
 			for _, beforeGame := range gamesBeforeSync {
@@ -415,8 +415,8 @@ func syncGameNew(file os.DirEntry, foldersToSkip []string, baseDir string, full
 			zap.String("game", file.Name()),
 			zap.String("hash", dirHash),
 			zap.String("status", status.String()))
-		err = repo.RemoveDeletionDate(BackendCtx(), id)
-		handleError("RemoveDeletionDate", err, "")
+		err = repo.RemoveSoundtrackDeletionDate(BackendCtx(), id)
+		handleError("RemoveSoundtrackDeletionDate", err, "")
 	}
 	foldersSynced++
 	logging.GetLogger().Debug("Sync progress",
@@ -427,14 +427,14 @@ func syncGameNew(file os.DirEntry, foldersToSkip []string, baseDir string, full
 
 func insertGameNew(name string, path string, hash string) int32 {
 	var duplicateError = errors.New("ERROR: duplicate key value violates unique")
-	id, err := repo.InsertGame(BackendCtx(), repository.InsertGameParams{GameName: name, Path: path, Hash: hash})
-	handleError("InsertGame", err, "")
+	id, err := repo.InsertSoundtrack(BackendCtx(), repository.InsertSoundtrackParams{SoundtrackName: name, Path: path, Hash: hash})
+	handleError("InsertSoundtrack", err, "")
 	if err != nil {
 		logging.GetLogger().Warn("ID collision detected, resetting sequence")
 		if strings.HasPrefix(err.Error(), duplicateError.Error()) {
 			logging.GetLogger().Debug("Resetting game ID sequence")
-			_, err = repo.ResetGameIdSeq(BackendCtx())
-			handleError("ResetGameIdSeq", err, "")
+			_, err = repo.ResetSoundtrackIdSeq(BackendCtx())
+			handleError("ResetSoundtrackIdSeq", err, "")
 			id = insertGameNew(name, path, hash)
 		}
 	}
@@ -478,7 +478,7 @@ func newCheckSong(entry os.DirEntry, gameDir string, id int32) bool {
 		songName, _ := strings.CutSuffix(fileName, ".mp3")
 
 		song, err := repo.GetSongWithHash(BackendCtx(), songHash)
-		handleError("GetSongWithHash", err, fmt.Sprintf("GameID: %d | Path: %s | SongName: %s | SongHash: %s", id, path, entry.Name(), songHash))
+		handleError("GetSongWithHash", err, fmt.Sprintf("SoundtrackID: %d | Path: %s | SongName: %s | SongHash: %s", id, path, entry.Name(), songHash))
 		if err == nil {
 			if song.SongName == songName && song.Path == path {
 				return false
@@ -491,31 +491,31 @@ func newCheckSong(entry os.DirEntry, gameDir string, id int32) bool {
 			zap.String("song_hash", songHash))
 
 		count, err := repo.CheckSongWithHash(BackendCtx(), songHash)
-		handleError("CheckSongWithHash", err, fmt.Sprintf("GameID: %d | Path: %s | SongName: %s | SongHash: %s\n", id, path, entry.Name(), songHash))
+		handleError("CheckSongWithHash", err, fmt.Sprintf("SoundtrackID: %d | Path: %s | SongName: %s | SongHash: %s\n", id, path, entry.Name(), songHash))
 		if err != nil {
 			count2, err := repo.CheckSong(BackendCtx(), path)
-			handleError("CheckSong", err, fmt.Sprintf("GameID: %d | Path: %s | SongName: %s | SongHash: %s\n", id, path, entry.Name(), songHash))
+			handleError("CheckSong", err, fmt.Sprintf("SoundtrackID: %d | Path: %s | SongName: %s | SongHash: %s\n", id, path, entry.Name(), songHash))
 			if count2 > 0 {
 				err = repo.AddHashToSong(BackendCtx(), repository.AddHashToSongParams{Hash: songHash, Path: path})
-				handleError("AddHashToSong", err, fmt.Sprintf("GameID: %d | Path: %s | SongName: %s | SongHash: %s", id, path, entry.Name(), songHash))
+				handleError("AddHashToSong", err, fmt.Sprintf("SoundtrackID: %d | Path: %s | SongName: %s | SongHash: %s", id, path, entry.Name(), songHash))
 				count, err = repo.CheckSongWithHash(BackendCtx(), songHash)
-				handleError("CheckSongWithHash 2", err, fmt.Sprintf("GameID: %d | Path: %s | SongName: %s | SongHash: %s", id, path, entry.Name(), songHash))
+				handleError("CheckSongWithHash 2", err, fmt.Sprintf("SoundtrackID: %d | Path: %s | SongName: %s | SongHash: %s", id, path, entry.Name(), songHash))
 			}
 		}
 
 		//count, _ := repo.CheckSong(ctx, path)
 		if count > 0 {
 			err = repo.UpdateSong(BackendCtx(), repository.UpdateSongParams{SongName: songName, FileName: &fileName, Path: path, Hash: songHash})
-			handleError("UpdateSong", err, fmt.Sprintf("GameID: %d | Path: %s | SongName: %s | SongHash: %s", id, path, entry.Name(), songHash))
+			handleError("UpdateSong", err, fmt.Sprintf("SoundtrackID: %d | Path: %s | SongName: %s | SongHash: %s", id, path, entry.Name(), songHash))
 		} else {
 			count2, err := repo.CheckSong(BackendCtx(), path)
-			handleError("CheckSong", err, fmt.Sprintf("GameID: %d | Path: %s | SongName: %s | SongHash: %s", id, path, entry.Name(), songHash))
+			handleError("CheckSong", err, fmt.Sprintf("SoundtrackID: %d | Path: %s | SongName: %s | SongHash: %s", id, path, entry.Name(), songHash))
 			if count2 > 0 {
 				err = repo.AddHashToSong(BackendCtx(), repository.AddHashToSongParams{Hash: songHash, Path: path})
-				handleError("AddHashToSong", err, fmt.Sprintf("GameID: %d | Path: %s | SongName: %s | SongHash: %s", id, path, entry.Name(), songHash))
+				handleError("AddHashToSong", err, fmt.Sprintf("SoundtrackID: %d | Path: %s | SongName: %s | SongHash: %s", id, path, entry.Name(), songHash))
 			} else {
-				err = repo.AddSong(BackendCtx(), repository.AddSongParams{GameID: id, SongName: songName, Path: path, FileName: &fileName, Hash: songHash})
-				handleError("AddSong", err, fmt.Sprintf("GameID: %d | Path: %s | SongName: %s | SongHash: %s", id, path, entry.Name(), songHash))
+				err = repo.AddSong(BackendCtx(), repository.AddSongParams{SoundtrackID: id, SongName: songName, Path: path, FileName: &fileName, Hash: songHash})
+				handleError("AddSong", err, fmt.Sprintf("SoundtrackID: %d | Path: %s | SongName: %s | SongHash: %s", id, path, entry.Name(), songHash))
 
 			}
 		}