Cache stuff.

Author: goatonabicycle

internal/admin/handlers.go

@@ -45,7 +45,8 @@ func (h *Handler) AdminHandler(c echo.Context) error {
 		}, c)
 	}
 
-	allAlbums, err := loader.LoadAllAlbumsData()
+	// Only fetch artist and album names for all albums (fast)
+	allAlbums, err := loader.FetchAlbumNamesOnly()
 	if err != nil {
 		log.Printf("Error loading albums: %v", err)
 		return err
@@ -232,7 +233,8 @@ func (h *Handler) AlbumListHandler(c echo.Context) error {
 	if err := validateAuth(c); err != nil {
 		return err
 	}
-	albums, err := loader.LoadAllAlbumsData()
+	// Only fetch artist and album names for all albums
+	albums, err := loader.FetchAlbumNamesOnly()
 	if err != nil {
 		return c.HTML(500, "Failed to load albums")
 	}

loaders/sqlite/loader.go

@@ -298,3 +298,29 @@ func SaveAlbum(album models.BandcampAlbumData) error {
 
 	return tx.Commit()
 }
+
+func FetchAlbumNamesOnly() ([]models.BandcampAlbumData, error) {
+	db, err := sql.Open("sqlite", dbPath)
+	if err != nil {
+		return nil, fmt.Errorf("error opening database at %s: %w", dbPath, err)
+	}
+	defer db.Close()
+
+	query := `SELECT artist_name, album_name FROM albums ORDER BY date_added DESC`
+	rows, err := db.Query(query)
+	if err != nil {
+		return nil, fmt.Errorf("error querying albums: %w", err)
+	}
+	defer rows.Close()
+
+	var albums []models.BandcampAlbumData
+	for rows.Next() {
+		var album models.BandcampAlbumData
+		if err := rows.Scan(&album.ArtistName, &album.AlbumName); err != nil {
+			return nil, fmt.Errorf("error scanning album row: %w", err)
+		}
+		albums = append(albums, album)
+	}
+
+	return albums, nil
+}

loaders/supabase/loader.go

@@ -436,3 +436,24 @@ func UpdateAlbum(req models.UpdateAlbumRequest) error {
 	log.Printf("Verified updated album values: %+v", album)
 	return nil
 }
+
+func FetchAlbumNamesOnly() ([]models.BandcampAlbumData, error) {
+	query := publicClient.From("albums").
+		Select("artist_name, album_name", "exact", false).
+		Order("date_added", &postgrest.OrderOpts{
+			Ascending:  false,
+			NullsFirst: false,
+		})
+
+	data, _, err := query.Execute()
+	if err != nil {
+		return nil, fmt.Errorf("error querying albums: %w", err)
+	}
+
+	var albums []models.BandcampAlbumData
+	if err := json.Unmarshal(data, &albums); err != nil {
+		return nil, fmt.Errorf("error scanning album rows: %w", err)
+	}
+
+	return albums, nil
+}

main.go

@@ -32,6 +32,27 @@ const (
 
 var (
 	albums []models.BandcampAlbumData
+	// Add a cache for home page stats
+	homePageCache struct {
+		Albums             []models.BandcampAlbumData
+		TotalAlbums        int
+		TotalSongs         int
+		TotalWords         int
+		TotalChars         int
+		TotalCharsNoSpaces int
+		TotalVowels        int
+		TotalConsonants    int
+		TotalLines         int
+		TotalDuration      int
+		AvgWordsPerAlbum   int
+		AvgCharsPerAlbum   int
+		AvgWordLength      float64
+		AvgSongsPerAlbum   float64
+		WPM                int
+		ProjectedAlbums    float64
+		FuckCount          int
+		DisplayAlbums      []models.BandcampAlbumData
+	}
 )
 
 type TemplateRenderer struct {
@@ -57,6 +78,9 @@ func main() {
 	if err := loadAlbums(); err != nil {
 		e.Logger.Fatal(err)
 	}
+	if err := refreshHomePageCache(); err != nil {
+		e.Logger.Fatal(err)
+	}
 
 	setupRoutes(e)
 	setupAdminRoutes(e, renderer)
@@ -158,7 +182,7 @@ func countWordOccurrences(albums []models.BandcampAlbumData, word string) int {
 	return count
 }
 
-func indexHandler(c echo.Context) error {
+func refreshHomePageCache() error {
 	allAlbums, err := loader.LoadAlbumsData()
 	if err != nil {
 		return err
@@ -215,24 +239,67 @@ func indexHandler(c echo.Context) error {
 
 	fuckCount := countWordOccurrences(allAlbums, "fuck")
 
+	homePageCache = struct {
+		Albums             []models.BandcampAlbumData
+		TotalAlbums        int
+		TotalSongs         int
+		TotalWords         int
+		TotalChars         int
+		TotalCharsNoSpaces int
+		TotalVowels        int
+		TotalConsonants    int
+		TotalLines         int
+		TotalDuration      int
+		AvgWordsPerAlbum   int
+		AvgCharsPerAlbum   int
+		AvgWordLength      float64
+		AvgSongsPerAlbum   float64
+		WPM                int
+		ProjectedAlbums    float64
+		FuckCount          int
+		DisplayAlbums      []models.BandcampAlbumData
+	}{
+		Albums:             allAlbums,
+		TotalAlbums:        albumCount,
+		TotalSongs:         totalSongs,
+		TotalWords:         totalWords,
+		TotalChars:         totalChars,
+		TotalCharsNoSpaces: totalCharsNoSpaces,
+		TotalVowels:        totalVowels,
+		TotalConsonants:    totalConsonants,
+		TotalLines:         totalLines,
+		TotalDuration:      totalDuration / 60,
+		AvgWordsPerAlbum:   avgWordsPerAlbum,
+		AvgCharsPerAlbum:   totalChars / max(albumCount, 1),
+		AvgWordLength:      avgWordLength,
+		AvgSongsPerAlbum:   avgSongsPerAlbum,
+		WPM:                wpm,
+		ProjectedAlbums:    projectedAlbums,
+		FuckCount:          fuckCount,
+		DisplayAlbums:      displayAlbums,
+	}
+	return nil
+}
+
+func indexHandler(c echo.Context) error {
 	return renderTemplate(c, "index.html", map[string]interface{}{
-		"albums":             displayAlbums,
-		"TotalAlbums":        albumCount,
-		"TotalSongs":         totalSongs,
-		"TotalWords":         totalWords,
-		"TotalChars":         totalChars,
-		"TotalCharsNoSpaces": totalCharsNoSpaces,
-		"TotalVowels":        totalVowels,
-		"TotalConsonants":    totalConsonants,
-		"TotalLines":         totalLines,
-		"TotalDuration":      totalDuration / 60,
-		"AvgWordsPerAlbum":   avgWordsPerAlbum,
-		"AvgCharsPerAlbum":   totalChars / max(albumCount, 1),
-		"AvgWordLength":      avgWordLength,
-		"AvgSongsPerAlbum":   avgSongsPerAlbum,
-		"WPM":                wpm,
-		"ProjectedAlbums":    projectedAlbums,
-		"FuckCount":          fuckCount,
+		"albums":             homePageCache.DisplayAlbums,
+		"TotalAlbums":        homePageCache.TotalAlbums,
+		"TotalSongs":         homePageCache.TotalSongs,
+		"TotalWords":         homePageCache.TotalWords,
+		"TotalChars":         homePageCache.TotalChars,
+		"TotalCharsNoSpaces": homePageCache.TotalCharsNoSpaces,
+		"TotalVowels":        homePageCache.TotalVowels,
+		"TotalConsonants":    homePageCache.TotalConsonants,
+		"TotalLines":         homePageCache.TotalLines,
+		"TotalDuration":      homePageCache.TotalDuration,
+		"AvgWordsPerAlbum":   homePageCache.AvgWordsPerAlbum,
+		"AvgCharsPerAlbum":   homePageCache.AvgCharsPerAlbum,
+		"AvgWordLength":      homePageCache.AvgWordLength,
+		"AvgSongsPerAlbum":   homePageCache.AvgSongsPerAlbum,
+		"WPM":                homePageCache.WPM,
+		"ProjectedAlbums":    homePageCache.ProjectedAlbums,
+		"FuckCount":          homePageCache.FuckCount,
 	})
 }
 
@@ -541,6 +608,9 @@ func importAlbumHandler(c echo.Context) error {
 	if err := loadAlbums(); err != nil {
 		log.Printf("Error reloading albums after import: %v", err)
 	}
+	if err := refreshHomePageCache(); err != nil {
+		log.Printf("Error refreshing home page cache after import: %v", err)
+	}
 
 	log.Printf("Import complete")
 	return c.HTML(http.StatusOK, strings.Join(results, "\n"))