lyrics

artist.go (6375B)

---

 package db
 
 import (
 	"fmt"
 	"lyrics/internal/domain"
 	"strings"
 	"time"
 )
 
 func Artist(e Execer, id domain.ArtistID) (domain.Artist, []domain.Release, []domain.Song, []domain.Song, error) {
 	var artist domain.Artist
 
 	err := e.QueryRow(`
 		select id, musicbrainz_artist_id, name, latin_name, disambiguation, bio
 		from artists
 		where id = ?
 	`, id).Scan(&artist.ID, &artist.MusicBrainzArtistID, &artist.Name, &artist.LatinName, &artist.Disambiguation, &artist.Bio)
 	if err != nil {
 		return domain.Artist{}, nil, nil, nil, fmt.Errorf("failed to get artist: %w", err)
 	}
 
 	var releaseIDs []domain.ReleaseID
 	{
 		// fetch releases where artist is primary, ordered by release_date
 		rows, err := e.Query(`
 			select release_id
 			from release_artists
 			where artist_id = ?
 			  and role = ?
 			order by (select release_date from releases where id = release_id)
 		`, id, domain.RolePrimary)
 		if err != nil {
 			return domain.Artist{}, nil, nil, nil, fmt.Errorf("failed to query artist releases: %w", err)
 		}
 
 		for rows.Next() {
 			var releaseID domain.ReleaseID
 			if err := rows.Scan(&releaseID); err != nil {
 				_ = rows.Close()
 				return domain.Artist{}, nil, nil, nil, fmt.Errorf("failed to scan release id: %w", err)
 			}
 			releaseIDs = append(releaseIDs, releaseID)
 		}
 		if err := rows.Err(); err != nil {
 			_ = rows.Close()
 			return domain.Artist{}, nil, nil, nil, fmt.Errorf("failed to iterate artist releases: %w", err)
 		}
 		_ = rows.Close()
 	}
 
 	releases := make([]domain.Release, 0, len(releaseIDs))
 	for _, releaseID := range releaseIDs {
 		release, err := Release(e, releaseID)
 		if err != nil {
 			return domain.Artist{}, nil, nil, nil, fmt.Errorf("failed to get release %d: %w", releaseID, err)
 		}
 		releases = append(releases, release)
 	}
 
 	var singleIDs []domain.SongID
 	{
 		// fetch primary singles (primary role, no release) ordered by release_date
 		rows, err := e.Query(`
 			select sa.song_id
 			from song_artists sa
 			join songs s on s.id = sa.song_id
 			where sa.artist_id = ?
 			  and sa.role = ?
 			  and not exists (select 1 from song_releases where song_id = sa.song_id)
 			order by s.release_date
 		`, id, domain.RolePrimary)
 		if err != nil {
 			return domain.Artist{}, nil, nil, nil, fmt.Errorf("failed to query artist singles: %w", err)
 		}
 
 		for rows.Next() {
 			var songID domain.SongID
 			if err := rows.Scan(&songID); err != nil {
 				_ = rows.Close()
 				return domain.Artist{}, nil, nil, nil, fmt.Errorf("failed to scan single id: %w", err)
 			}
 			singleIDs = append(singleIDs, songID)
 		}
 		if err := rows.Err(); err != nil {
 			_ = rows.Close()
 			return domain.Artist{}, nil, nil, nil, fmt.Errorf("failed to iterate artist singles: %w", err)
 		}
 		_ = rows.Close()
 	}
 
 	singles := make([]domain.Song, 0, len(singleIDs))
 	for _, songID := range singleIDs {
 		song, err := Song(e, songID)
 		if err != nil {
 			return domain.Artist{}, nil, nil, nil, fmt.Errorf("failed to get single %d: %w", songID, err)
 		}
 		singles = append(singles, song)
 	}
 
 	var featuredIDs []domain.SongID
 	{
 		// fetch featured songs (featured role, regardless of release) ordered by release_date
 		rows, err := e.Query(`
 			select sa.song_id
 			from song_artists sa
 			join songs s on s.id = sa.song_id
 			where sa.artist_id = ?
 			  and sa.role = ?
 			order by s.release_date
 		`, id, domain.RoleFeatured)
 		if err != nil {
 			return domain.Artist{}, nil, nil, nil, fmt.Errorf("failed to query featured songs: %w", err)
 		}
 
 		for rows.Next() {
 			var songID domain.SongID
 			if err := rows.Scan(&songID); err != nil {
 				_ = rows.Close()
 				return domain.Artist{}, nil, nil, nil, fmt.Errorf("failed to scan featured song id: %w", err)
 			}
 			featuredIDs = append(featuredIDs, songID)
 		}
 		if err := rows.Err(); err != nil {
 			_ = rows.Close()
 			return domain.Artist{}, nil, nil, nil, fmt.Errorf("failed to iterate featured songs: %w", err)
 		}
 		_ = rows.Close()
 	}
 
 	featured := make([]domain.Song, 0, len(featuredIDs))
 	for _, songID := range featuredIDs {
 		song, err := Song(e, songID)
 		if err != nil {
 			return domain.Artist{}, nil, nil, nil, fmt.Errorf("failed to get featured song %d: %w", songID, err)
 		}
 		featured = append(featured, song)
 	}
 
 	return artist, releases, singles, featured, nil
 }
 
 func InsertArtist(e Execer, artist domain.Artist) error {
 	_, err := e.Exec(`
 		insert into artists (
 			musicbrainz_artist_id,
 			name,
 			latin_name,
 			disambiguation,
 			bio,
 			created_at
 		)
 		values (?, ?, ?, ?, ?, ?)
 	`, artist.MusicBrainzArtistID, artist.Name, artist.LatinName, artist.Disambiguation, artist.Bio, time.Now().Format(time.RFC3339))
 	if err != nil {
 		return fmt.Errorf("failed to insert artist: %w", err)
 	}
 
 	return nil
 }
 
 func UpdateArtist(e Execer, artist domain.Artist) error {
 	_, err := e.Exec(`
 		update artists
 		set
 			musicbrainz_artist_id = ?,
 			name = ?,
 			latin_name = ?,
 			disambiguation = ?,
 			bio = ?
 		where id = ?
 	`, artist.MusicBrainzArtistID, artist.Name, artist.LatinName, artist.Disambiguation, artist.Bio, artist.ID)
 	if err != nil {
 		return fmt.Errorf("failed to update artist: %w", err)
 	}
 
 	return nil
 }
 
 func SearchArtist(e Execer, artistName string, limit, offset int64) (int, []domain.Artist, error) {
 	artistName = strings.TrimSpace(artistName)
 	if artistName == "" {
 		return 0, nil, nil
 	}
 
 	wildcard := "%" + artistName + "%"
 
 	var totalRows int
 	err := e.QueryRow(`
 		select count(*)
 		from artists
 		where name like ? collate nocase
 		   or latin_name like ? collate nocase
 	`, wildcard, wildcard).Scan(&totalRows)
 	if err != nil {
 		return 0, nil, fmt.Errorf("failed to count total artists: %w", err)
 	}
 
 	rows, err := e.Query(`
 		select id, musicbrainz_artist_id, name, latin_name, disambiguation, bio
 		from artists
 		where name like ? collate nocase
 		   or latin_name like ? collate nocase
 		order by name
 		limit ? offset ?
 	`, wildcard, wildcard, limit, offset)
 	if err != nil {
 		return 0, nil, fmt.Errorf("failed to query artists: %w", err)
 	}
 	defer func() {
 		_ = rows.Close()
 	}()
 
 	var results []domain.Artist
 	for rows.Next() {
 		var artist domain.Artist
 		if err := rows.Scan(&artist.ID, &artist.MusicBrainzArtistID, &artist.Name, &artist.LatinName, &artist.Disambiguation, &artist.Bio); err != nil {
 			return 0, nil, fmt.Errorf("failed to scan artist row: %w", err)
 		}
 		results = append(results, artist)
 	}
 
 	return totalRows, results, rows.Err()
 }