feat: all time rank display (#149)

* add all time rank to item pages

* fix artist albums component

* add no rows check

* fix rewind page

internal/db/psql/album.go

@@ -23,32 +23,13 @@ func (d *Psql) GetAlbum(ctx context.Context, opts db.GetAlbumOpts) (*models.Albu
 	var err error
 	var ret = new(models.Album)
 
-	if opts.ID != 0 {
-		l.Debug().Msgf("Fetching album from DB with id %d", opts.ID)
-		row, err := d.q.GetRelease(ctx, opts.ID)
-		if err != nil {
-			return nil, fmt.Errorf("GetAlbum: %w", err)
-		}
-		ret.ID = row.ID
-		ret.MbzID = row.MusicBrainzID
-		ret.Title = row.Title
-		ret.Image = row.Image
-		ret.VariousArtists = row.VariousArtists
-		err = json.Unmarshal(row.Artists, &ret.Artists)
-		if err != nil {
-			return nil, fmt.Errorf("GetAlbum: json.Unmarshal: %w", err)
-		}
-	} else if opts.MusicBrainzID != uuid.Nil {
+	if opts.MusicBrainzID != uuid.Nil {
 		l.Debug().Msgf("Fetching album from DB with MusicBrainz Release ID %s", opts.MusicBrainzID)
 		row, err := d.q.GetReleaseByMbzID(ctx, &opts.MusicBrainzID)
 		if err != nil {
 			return nil, fmt.Errorf("GetAlbum: %w", err)
 		}
-		ret.ID = row.ID
-		ret.MbzID = row.MusicBrainzID
-		ret.Title = row.Title
-		ret.Image = row.Image
-		ret.VariousArtists = row.VariousArtists
+		opts.ID = row.ID
 	} else if opts.ArtistID != 0 && opts.Title != "" {
 		l.Debug().Msgf("Fetching album from DB with artist_id %d and title %s", opts.ArtistID, opts.Title)
 		row, err := d.q.GetReleaseByArtistAndTitle(ctx, repository.GetReleaseByArtistAndTitleParams{
@@ -58,11 +39,7 @@ func (d *Psql) GetAlbum(ctx context.Context, opts db.GetAlbumOpts) (*models.Albu
 		if err != nil {
 			return nil, fmt.Errorf("GetAlbum: %w", err)
 		}
-		ret.ID = row.ID
-		ret.MbzID = row.MusicBrainzID
-		ret.Title = row.Title
-		ret.Image = row.Image
-		ret.VariousArtists = row.VariousArtists
+		opts.ID = row.ID
 	} else if opts.ArtistID != 0 && len(opts.Titles) > 0 {
 		l.Debug().Msgf("Fetching release group from DB with artist_id %d and titles %v", opts.ArtistID, opts.Titles)
 		row, err := d.q.GetReleaseByArtistAndTitles(ctx, repository.GetReleaseByArtistAndTitlesParams{
@@ -72,19 +49,19 @@ func (d *Psql) GetAlbum(ctx context.Context, opts db.GetAlbumOpts) (*models.Albu
 		if err != nil {
 			return nil, fmt.Errorf("GetAlbum: %w", err)
 		}
-		ret.ID = row.ID
-		ret.MbzID = row.MusicBrainzID
-		ret.Title = row.Title
-		ret.Image = row.Image
-		ret.VariousArtists = row.VariousArtists
-	} else {
-		return nil, errors.New("GetAlbum: insufficient information to get album")
+		opts.ID = row.ID
+	}
+
+	l.Debug().Msgf("Fetching album from DB with id %d", opts.ID)
+	row, err := d.q.GetRelease(ctx, opts.ID)
+	if err != nil {
+		return nil, fmt.Errorf("GetAlbum: %w", err)
 	}
 
 	count, err := d.q.CountListensFromRelease(ctx, repository.CountListensFromReleaseParams{
 		ListenedAt:   time.Unix(0, 0),
 		ListenedAt_2: time.Now(),
-		ReleaseID:    ret.ID,
+		ReleaseID:    opts.ID,
 	})
 	if err != nil {
 		return nil, fmt.Errorf("GetAlbum: CountListensFromRelease: %w", err)
@@ -92,17 +69,32 @@ func (d *Psql) GetAlbum(ctx context.Context, opts db.GetAlbumOpts) (*models.Albu
 
 	seconds, err := d.CountTimeListenedToItem(ctx, db.TimeListenedOpts{
 		Timeframe: db.Timeframe{Period: db.PeriodAllTime},
-		AlbumID:   ret.ID,
+		AlbumID:   opts.ID,
 	})
 	if err != nil {
 		return nil, fmt.Errorf("GetAlbum: CountTimeListenedToItem: %w", err)
 	}
 
-	firstListen, err := d.q.GetFirstListenFromRelease(ctx, ret.ID)
+	firstListen, err := d.q.GetFirstListenFromRelease(ctx, opts.ID)
 	if err != nil && !errors.Is(err, pgx.ErrNoRows) {
 		return nil, fmt.Errorf("GetAlbum: GetFirstListenFromRelease: %w", err)
 	}
 
+	rank, err := d.q.GetReleaseAllTimeRank(ctx, opts.ID)
+	if err != nil && !errors.Is(err, pgx.ErrNoRows) {
+		return nil, fmt.Errorf("GetAlbum: GetReleaseAllTimeRank: %w", err)
+	}
+
+	ret.ID = row.ID
+	ret.MbzID = row.MusicBrainzID
+	ret.Title = row.Title
+	ret.Image = row.Image
+	ret.VariousArtists = row.VariousArtists
+	err = json.Unmarshal(row.Artists, &ret.Artists)
+	if err != nil {
+		return nil, fmt.Errorf("GetAlbum: json.Unmarshal: %w", err)
+	}
+	ret.AllTimeRank = rank.Rank
 	ret.ListenCount = count
 	ret.TimeListened = seconds
 	ret.FirstListen = firstListen.ListenedAt.Unix()

internal/db/psql/artist.go

@@ -20,114 +20,60 @@ import (
 // this function sucks because sqlc keeps making new types for rows that are the same
 func (d *Psql) GetArtist(ctx context.Context, opts db.GetArtistOpts) (*models.Artist, error) {
 	l := logger.FromContext(ctx)
-	if opts.ID != 0 {
-		l.Debug().Msgf("Fetching artist from DB with id %d", opts.ID)
-		row, err := d.q.GetArtist(ctx, opts.ID)
-		if err != nil {
-			return nil, fmt.Errorf("GetArtist: GetArtist by ID: %w", err)
-		}
-		count, err := d.q.CountListensFromArtist(ctx, repository.CountListensFromArtistParams{
-			ListenedAt:   time.Unix(0, 0),
-			ListenedAt_2: time.Now(),
-			ArtistID:     row.ID,
-		})
-		if err != nil {
-			return nil, fmt.Errorf("GetArtist: CountListensFromArtist: %w", err)
-		}
-		seconds, err := d.CountTimeListenedToItem(ctx, db.TimeListenedOpts{
-			Timeframe: db.Timeframe{Period: db.PeriodAllTime},
-			ArtistID:  row.ID,
-		})
-		if err != nil {
-			return nil, fmt.Errorf("GetArtist: CountTimeListenedToItem: %w", err)
-		}
-		firstListen, err := d.q.GetFirstListenFromArtist(ctx, row.ID)
-		if err != nil && !errors.Is(err, pgx.ErrNoRows) {
-			return nil, fmt.Errorf("GetAlbum: GetFirstListenFromArtist: %w", err)
-		}
-		return &models.Artist{
-			ID:           row.ID,
-			MbzID:        row.MusicBrainzID,
-			Name:         row.Name,
-			Aliases:      row.Aliases,
-			Image:        row.Image,
-			ListenCount:  count,
-			TimeListened: seconds,
-			FirstListen:  firstListen.ListenedAt.Unix(),
-		}, nil
-	} else if opts.MusicBrainzID != uuid.Nil {
+	if opts.MusicBrainzID != uuid.Nil {
 		l.Debug().Msgf("Fetching artist from DB with MusicBrainz ID %s", opts.MusicBrainzID)
 		row, err := d.q.GetArtistByMbzID(ctx, &opts.MusicBrainzID)
 		if err != nil {
 			return nil, fmt.Errorf("GetArtist: GetArtistByMbzID: %w", err)
 		}
-		count, err := d.q.CountListensFromArtist(ctx, repository.CountListensFromArtistParams{
-			ListenedAt:   time.Unix(0, 0),
-			ListenedAt_2: time.Now(),
-			ArtistID:     row.ID,
-		})
-		if err != nil {
-			return nil, fmt.Errorf("GetArtist: CountListensFromArtist: %w", err)
-		}
-		seconds, err := d.CountTimeListenedToItem(ctx, db.TimeListenedOpts{
-			Timeframe: db.Timeframe{Period: db.PeriodAllTime},
-			ArtistID:  row.ID,
-		})
-		if err != nil {
-			return nil, fmt.Errorf("GetArtist: CountTimeListenedToItem: %w", err)
-		}
-		firstListen, err := d.q.GetFirstListenFromArtist(ctx, row.ID)
-		if err != nil && !errors.Is(err, pgx.ErrNoRows) {
-			return nil, fmt.Errorf("GetAlbum: GetFirstListenFromArtist: %w", err)
-		}
-		return &models.Artist{
-			ID:           row.ID,
-			MbzID:        row.MusicBrainzID,
-			Name:         row.Name,
-			Aliases:      row.Aliases,
-			Image:        row.Image,
-			ListenCount:  count,
-			TimeListened: seconds,
-			FirstListen:  firstListen.ListenedAt.Unix(),
-		}, nil
+		opts.ID = row.ID
 	} else if opts.Name != "" {
 		l.Debug().Msgf("Fetching artist from DB with name '%s'", opts.Name)
 		row, err := d.q.GetArtistByName(ctx, opts.Name)
 		if err != nil {
 			return nil, fmt.Errorf("GetArtist: GetArtistByName: %w", err)
 		}
-		count, err := d.q.CountListensFromArtist(ctx, repository.CountListensFromArtistParams{
-			ListenedAt:   time.Unix(0, 0),
-			ListenedAt_2: time.Now(),
-			ArtistID:     row.ID,
-		})
-		if err != nil {
-			return nil, fmt.Errorf("GetArtist: CountListensFromArtist: %w", err)
-		}
-		seconds, err := d.CountTimeListenedToItem(ctx, db.TimeListenedOpts{
-			Timeframe: db.Timeframe{Period: db.PeriodAllTime},
-			ArtistID:  row.ID,
-		})
-		if err != nil {
-			return nil, fmt.Errorf("GetArtist: CountTimeListenedToItem: %w", err)
-		}
-		firstListen, err := d.q.GetFirstListenFromArtist(ctx, row.ID)
-		if err != nil && !errors.Is(err, pgx.ErrNoRows) {
-			return nil, fmt.Errorf("GetAlbum: GetFirstListenFromArtist: %w", err)
-		}
-		return &models.Artist{
-			ID:           row.ID,
-			MbzID:        row.MusicBrainzID,
-			Name:         row.Name,
-			Aliases:      row.Aliases,
-			Image:        row.Image,
-			ListenCount:  count,
-			TimeListened: seconds,
-			FirstListen:  firstListen.ListenedAt.Unix(),
-		}, nil
-	} else {
-		return nil, errors.New("insufficient information to get artist")
+		opts.ID = row.ID
 	}
+	l.Debug().Msgf("Fetching artist from DB with id %d", opts.ID)
+	row, err := d.q.GetArtist(ctx, opts.ID)
+	if err != nil {
+		return nil, fmt.Errorf("GetArtist: GetArtist by ID: %w", err)
+	}
+	count, err := d.q.CountListensFromArtist(ctx, repository.CountListensFromArtistParams{
+		ListenedAt:   time.Unix(0, 0),
+		ListenedAt_2: time.Now(),
+		ArtistID:     row.ID,
+	})
+	if err != nil {
+		return nil, fmt.Errorf("GetArtist: CountListensFromArtist: %w", err)
+	}
+	seconds, err := d.CountTimeListenedToItem(ctx, db.TimeListenedOpts{
+		Timeframe: db.Timeframe{Period: db.PeriodAllTime},
+		ArtistID:  row.ID,
+	})
+	if err != nil {
+		return nil, fmt.Errorf("GetArtist: CountTimeListenedToItem: %w", err)
+	}
+	firstListen, err := d.q.GetFirstListenFromArtist(ctx, row.ID)
+	if err != nil && !errors.Is(err, pgx.ErrNoRows) {
+		return nil, fmt.Errorf("GetAlbum: GetFirstListenFromArtist: %w", err)
+	}
+	rank, err := d.q.GetArtistAllTimeRank(ctx, opts.ID)
+	if err != nil && !errors.Is(err, pgx.ErrNoRows) {
+		return nil, fmt.Errorf("GetArtist: GetArtistAllTimeRank: %w", err)
+	}
+	return &models.Artist{
+		ID:           row.ID,
+		MbzID:        row.MusicBrainzID,
+		Name:         row.Name,
+		Aliases:      row.Aliases,
+		Image:        row.Image,
+		ListenCount:  count,
+		TimeListened: seconds,
+		AllTimeRank:  rank.Rank,
+		FirstListen:  firstListen.ListenedAt.Unix(),
+	}, nil
 }
 
 // Inserts all unique aliases into the DB with specified source

internal/db/psql/track.go

@@ -21,37 +21,13 @@ func (d *Psql) GetTrack(ctx context.Context, opts db.GetTrackOpts) (*models.Trac
 	l := logger.FromContext(ctx)
 	var track models.Track
 
-	if opts.ID != 0 {
-		l.Debug().Msgf("Fetching track from DB with id %d", opts.ID)
-		t, err := d.q.GetTrack(ctx, opts.ID)
-		if err != nil {
-			return nil, fmt.Errorf("GetTrack: GetTrack By ID: %w", err)
-		}
-		track = models.Track{
-			ID:       t.ID,
-			MbzID:    t.MusicBrainzID,
-			Title:    t.Title,
-			AlbumID:  t.ReleaseID,
-			Image:    t.Image,
-			Duration: t.Duration,
-		}
-		err = json.Unmarshal(t.Artists, &track.Artists)
-		if err != nil {
-			return nil, fmt.Errorf("GetTrack: json.Unmarshal: %w", err)
-		}
-	} else if opts.MusicBrainzID != uuid.Nil {
+	if opts.MusicBrainzID != uuid.Nil {
 		l.Debug().Msgf("Fetching track from DB with MusicBrainz ID %s", opts.MusicBrainzID)
 		t, err := d.q.GetTrackByMbzID(ctx, &opts.MusicBrainzID)
 		if err != nil {
 			return nil, fmt.Errorf("GetTrack: GetTrackByMbzID: %w", err)
 		}
-		track = models.Track{
-			ID:       t.ID,
-			MbzID:    t.MusicBrainzID,
-			Title:    t.Title,
-			AlbumID:  t.ReleaseID,
-			Duration: t.Duration,
-		}
+		opts.ID = t.ID
 	} else if len(opts.ArtistIDs) > 0 && opts.ReleaseID != 0 {
 		l.Debug().Msgf("Fetching track from DB from release id %d with title '%s' and artist id(s) '%v'", opts.ReleaseID, opts.Title, opts.ArtistIDs)
 		t, err := d.q.GetTrackByTrackInfo(ctx, repository.GetTrackByTrackInfoParams{
@@ -62,21 +38,19 @@ func (d *Psql) GetTrack(ctx context.Context, opts db.GetTrackOpts) (*models.Trac
 		if err != nil {
 			return nil, fmt.Errorf("GetTrack: GetTrackByTrackInfo: %w", err)
 		}
-		track = models.Track{
-			ID:       t.ID,
-			MbzID:    t.MusicBrainzID,
-			Title:    t.Title,
-			AlbumID:  t.ReleaseID,
-			Duration: t.Duration,
-		}
-	} else {
-		return nil, errors.New("GetTrack: insufficient information to get track")
+		opts.ID = t.ID
+	}
+
+	l.Debug().Msgf("Fetching track from DB with id %d", opts.ID)
+	t, err := d.q.GetTrack(ctx, opts.ID)
+	if err != nil {
+		return nil, fmt.Errorf("GetTrack: GetTrack By ID: %w", err)
 	}
 
 	count, err := d.q.CountListensFromTrack(ctx, repository.CountListensFromTrackParams{
 		ListenedAt:   time.Unix(0, 0),
 		ListenedAt_2: time.Now(),
-		TrackID:      track.ID,
+		TrackID:      opts.ID,
 	})
 	if err != nil {
 		return nil, fmt.Errorf("GetTrack: CountListensFromTrack: %w", err)
@@ -84,20 +58,37 @@ func (d *Psql) GetTrack(ctx context.Context, opts db.GetTrackOpts) (*models.Trac
 
 	seconds, err := d.CountTimeListenedToItem(ctx, db.TimeListenedOpts{
 		Timeframe: db.Timeframe{Period: db.PeriodAllTime},
-		TrackID:   track.ID,
+		TrackID:   opts.ID,
 	})
 	if err != nil {
 		return nil, fmt.Errorf("GetTrack: CountTimeListenedToItem: %w", err)
 	}
 
-	firstListen, err := d.q.GetFirstListenFromTrack(ctx, track.ID)
+	firstListen, err := d.q.GetFirstListenFromTrack(ctx, opts.ID)
 	if err != nil && !errors.Is(err, pgx.ErrNoRows) {
 		return nil, fmt.Errorf("GetAlbum: GetFirstListenFromRelease: %w", err)
 	}
+	rank, err := d.q.GetTrackAllTimeRank(ctx, opts.ID)
+	if err != nil && !errors.Is(err, pgx.ErrNoRows) {
+		return nil, fmt.Errorf("GetAlbum: GetTrackAllTimeRank: %w", err)
+	}
 
-	track.ListenCount = count
-	track.TimeListened = seconds
-	track.FirstListen = firstListen.ListenedAt.Unix()
+	track = models.Track{
+		ID:           t.ID,
+		MbzID:        t.MusicBrainzID,
+		Title:        t.Title,
+		AlbumID:      t.ReleaseID,
+		Image:        t.Image,
+		Duration:     t.Duration,
+		AllTimeRank:  rank.Rank,
+		ListenCount:  count,
+		TimeListened: seconds,
+		FirstListen:  firstListen.ListenedAt.Unix(),
+	}
+	err = json.Unmarshal(t.Artists, &track.Artists)
+	if err != nil {
+		return nil, fmt.Errorf("GetTrack: json.Unmarshal: %w", err)
+	}
 
 	return &track, nil
 }

internal/models/album.go

@@ -12,11 +12,5 @@ type Album struct {
 	ListenCount    int64          `json:"listen_count"`
 	TimeListened   int64          `json:"time_listened"`
 	FirstListen    int64          `json:"first_listen"`
+	AllTimeRank    int64          `json:"all_time_rank"`
 }
-
-// type SimpleAlbum struct {
-// 	ID             int32     `json:"id"`
-// 	Title          string    `json:"title"`
-// 	VariousArtists bool      `json:"is_various_artists"`
-// 	Image          uuid.UUID `json:"image"`
-// }

internal/models/artist.go

@@ -12,6 +12,7 @@ type Artist struct {
 	TimeListened int64      `json:"time_listened"`
 	FirstListen  int64      `json:"first_listen"`
 	IsPrimary    bool       `json:"is_primary,omitempty"`
+	AllTimeRank  int64      `json:"all_time_rank"`
 }
 
 type SimpleArtist struct {

internal/models/track.go

@@ -13,4 +13,5 @@ type Track struct {
 	AlbumID      int32          `json:"album_id"`
 	TimeListened int64          `json:"time_listened"`
 	FirstListen  int64          `json:"first_listen"`
+	AllTimeRank  int64          `json:"all_time_rank"`
 }

internal/repository/artist.sql.go

@@ -134,6 +134,39 @@ func (q *Queries) GetArtist(ctx context.Context, id int32) (GetArtistRow, error)
 	return i, err
 }
 
+const getArtistAllTimeRank = `-- name: GetArtistAllTimeRank :one
+SELECT
+    artist_id,
+    rank
+FROM (
+    SELECT
+        x.artist_id,
+        RANK() OVER (ORDER BY x.listen_count DESC) AS rank
+    FROM (
+        SELECT
+            at.artist_id,
+            COUNT(*) AS listen_count
+        FROM listens l
+        JOIN tracks t ON l.track_id = t.id
+        JOIN artist_tracks at ON t.id = at.track_id
+        GROUP BY at.artist_id
+        ) x
+    )
+WHERE artist_id = $1
+`
+
+type GetArtistAllTimeRankRow struct {
+	ArtistID int32
+	Rank     int64
+}
+
+func (q *Queries) GetArtistAllTimeRank(ctx context.Context, artistID int32) (GetArtistAllTimeRankRow, error) {
+	row := q.db.QueryRow(ctx, getArtistAllTimeRank, artistID)
+	var i GetArtistAllTimeRankRow
+	err := row.Scan(&i.ArtistID, &i.Rank)
+	return i, err
+}
+
 const getArtistByImage = `-- name: GetArtistByImage :one
 SELECT id, musicbrainz_id, image, image_source FROM artists WHERE image = $1 LIMIT 1
 `

internal/repository/release.sql.go

@@ -141,6 +141,38 @@ func (q *Queries) GetRelease(ctx context.Context, id int32) (GetReleaseRow, erro
 	return i, err
 }
 
+const getReleaseAllTimeRank = `-- name: GetReleaseAllTimeRank :one
+SELECT
+    release_id,
+    rank
+FROM (
+    SELECT
+        x.release_id,
+        RANK() OVER (ORDER BY x.listen_count DESC) AS rank
+    FROM (
+        SELECT
+            t.release_id,
+            COUNT(*) AS listen_count
+        FROM listens l
+        JOIN tracks t ON l.track_id = t.id
+        GROUP BY t.release_id
+        ) x
+    )
+WHERE release_id = $1
+`
+
+type GetReleaseAllTimeRankRow struct {
+	ReleaseID int32
+	Rank      int64
+}
+
+func (q *Queries) GetReleaseAllTimeRank(ctx context.Context, releaseID int32) (GetReleaseAllTimeRankRow, error) {
+	row := q.db.QueryRow(ctx, getReleaseAllTimeRank, releaseID)
+	var i GetReleaseAllTimeRankRow
+	err := row.Scan(&i.ReleaseID, &i.Rank)
+	return i, err
+}
+
 const getReleaseByArtistAndTitle = `-- name: GetReleaseByArtistAndTitle :one
 SELECT r.id, r.musicbrainz_id, r.image, r.various_artists, r.image_source, r.title
 FROM releases_with_title r

internal/repository/track.sql.go

@@ -438,6 +438,37 @@ func (q *Queries) GetTrack(ctx context.Context, id int32) (GetTrackRow, error) {
 	return i, err
 }
 
+const getTrackAllTimeRank = `-- name: GetTrackAllTimeRank :one
+SELECT
+    id,
+    rank
+FROM (
+    SELECT
+        x.id,
+        RANK() OVER (ORDER BY x.listen_count DESC) AS rank
+    FROM (
+        SELECT
+            t.id,
+            COUNT(*) AS listen_count
+        FROM listens l
+        JOIN tracks_with_title t ON l.track_id = t.id
+        GROUP BY t.id) x
+    ) y
+WHERE id = $1
+`
+
+type GetTrackAllTimeRankRow struct {
+	ID   int32
+	Rank int64
+}
+
+func (q *Queries) GetTrackAllTimeRank(ctx context.Context, id int32) (GetTrackAllTimeRankRow, error) {
+	row := q.db.QueryRow(ctx, getTrackAllTimeRank, id)
+	var i GetTrackAllTimeRankRow
+	err := row.Scan(&i.ID, &i.Rank)
+	return i, err
+}
+
 const getTrackByMbzID = `-- name: GetTrackByMbzID :one
 SELECT id, musicbrainz_id, duration, release_id, title FROM tracks_with_title
 WHERE musicbrainz_id = $1 LIMIT 1