feat(M002): smart playlists — rule engine, editor UI, sidebar integration

Recovered from orphaned worktree commits (complete-milestone failed to merge). Backend: - Migration 9: is_smart + smart_rules columns on playlists table - smartplaylist package: parameterized WHERE clause builder, field whitelist, genre subquery - playlist.Service: Create/Update/Evaluate/Preview/GetRules smart playlist methods - 65 tests (49 rule engine + 15 service + 1 migration) Frontend: - yj-combobox: reusable typeable dropdown with keyboard nav, ARIA, blur-race fix - smart-playlist-editor: row-based rule builder with live preview - smart-playlist-details: evaluate, refresh, play, shuffle, edit rules - Sidebar: filter icon, Smart badge, create button, routing - Queue snapshot on play/shuffle
2026-03-21 12:53:00 -04:00
parent e974bd2a22
commit 477b7ff6a2
17 changed files with 5342 additions and 26 deletions
@@ -21,6 +21,8 @@ import (
 	"yellowjacket/backend/database"
 	"yellowjacket/backend/database/sql/sqlcgen"
 	"yellowjacket/backend/events"
+	"yellowjacket/backend/library"
+	"yellowjacket/backend/smartplaylist"
 	"yellowjacket/backend/system"
 )

@@ -48,6 +50,7 @@ type Summary struct {
 	Name      string `json:"Name"`
 	CreatedAt string `json:"CreatedAt"`
 	UpdatedAt string `json:"UpdatedAt"`
+	IsSmart   bool   `json:"IsSmart"`
 }

 // Track represents a track within a playlist, including its
@@ -185,6 +188,7 @@ func (s *Service) GetAllPlaylists() ([]Summary, error) {
 			Name:      p.Name,
 			CreatedAt: p.CreatedAt.Format(time.RFC3339),
 			UpdatedAt: p.UpdatedAt.Format(time.RFC3339),
+			IsSmart:   p.IsSmart != 0,
 		})
 	}

@@ -264,6 +268,7 @@ func (s *Service) GetAllPlaylistsWithTracks() (
 				Name:      p.Name,
 				CreatedAt: p.CreatedAt.Format(time.RFC3339),
 				UpdatedAt: p.UpdatedAt.Format(time.RFC3339),
+				IsSmart:   p.IsSmart != 0,
 			},
 			Tracks: tracks,
 		})
@@ -480,6 +485,7 @@ func (s *Service) CreatePlaylist(
 		Name:      created.Name,
 		CreatedAt: created.CreatedAt.Format(time.RFC3339),
 		UpdatedAt: created.UpdatedAt.Format(time.RFC3339),
+		IsSmart:   created.IsSmart != 0,
 	})

 	return Summary{
@@ -487,6 +493,7 @@ func (s *Service) CreatePlaylist(
 		Name:      created.Name,
 		CreatedAt: created.CreatedAt.Format(time.RFC3339),
 		UpdatedAt: created.UpdatedAt.Format(time.RFC3339),
+		IsSmart:   created.IsSmart != 0,
 	}, nil
 }

@@ -648,6 +655,7 @@ func (s *Service) CreatePlaylistWithTracks(
 		Name:      created.Name,
 		CreatedAt: created.CreatedAt.Format(time.RFC3339),
 		UpdatedAt: created.UpdatedAt.Format(time.RFC3339),
+		IsSmart:   created.IsSmart != 0,
 	}

 	s.logger.Info(
@@ -938,6 +946,7 @@ func (s *Service) ImportPlaylist(
 		Name:      playlistName,
 		CreatedAt: created.CreatedAt.Format(time.RFC3339),
 		UpdatedAt: created.UpdatedAt.Format(time.RFC3339),
+		IsSmart:   created.IsSmart != 0,
 	}

 	s.emitEvent(events.PlaylistCreated, summary)
@@ -2327,3 +2336,288 @@ func sortCandidatesByScore(candidates []CandidateTrack) {
 		},
 	)
 }
+
+// =================================================================
+// Smart playlist methods
+// =================================================================
+
+// errNotSmartPlaylist is returned when an operation that requires
+// a smart playlist is performed on a regular playlist or a
+// non-existent playlist.
+var errNotSmartPlaylist = errors.New(
+	"playlist not found or is not a smart playlist",
+)
+
+// errNoRowReturned is returned when an INSERT ... RETURNING
+// query does not return the expected row.
+var errNoRowReturned = errors.New(
+	"no row returned from insert",
+)
+
+// CreateSmartPlaylist creates a new smart playlist with the given
+// name and JSON rule set. The rules are validated before storage.
+func (s *Service) CreateSmartPlaylist(
+	name, rulesJSON string,
+) (Summary, error) {
+	trimmed := strings.TrimSpace(name)
+	if trimmed == "" {
+		return Summary{}, errEmptyName
+	}
+
+	// Validate rules JSON before storing.
+	if _, err := smartplaylist.ParseRuleSet(rulesJSON); err != nil {
+		return Summary{}, fmt.Errorf(
+			"invalid smart playlist rules: %w", err,
+		)
+	}
+
+	// SAFETY: Hand-crafted INSERT for smart playlist with
+	// is_smart and smart_rules columns not yet in sqlc schema.
+	// All values are parameterized.
+	rows, err := s.db.QueryContext(
+		`INSERT INTO playlists (name, is_smart, smart_rules)
+		 VALUES (?, 1, ?)
+		 RETURNING id, name, created_at, updated_at`,
+		trimmed, rulesJSON,
+	)
+	if err != nil {
+		s.logger.Error(
+			"Failed to create smart playlist",
+			"name", trimmed, "err", err,
+		)
+
+		return Summary{}, fmt.Errorf(
+			"failed to create smart playlist: %w", err,
+		)
+	}
+
+	defer func() { _ = rows.Close() }()
+
+	if !rows.Next() {
+		return Summary{}, fmt.Errorf(
+			"failed to create smart playlist: %w",
+			errNoRowReturned,
+		)
+	}
+
+	var (
+		id        int64
+		retName   string
+		createdAt string
+		updatedAt string
+	)
+
+	if err := rows.Scan(
+		&id, &retName, &createdAt, &updatedAt,
+	); err != nil {
+		s.logger.Error(
+			"Failed to create smart playlist",
+			"name", trimmed, "err", err,
+		)
+
+		return Summary{}, fmt.Errorf(
+			"failed to create smart playlist: %w", err,
+		)
+	}
+
+	s.logger.Info(
+		"Smart playlist created",
+		"id", id, "name", retName,
+	)
+
+	summary := Summary{
+		ID:        id,
+		Name:      retName,
+		CreatedAt: createdAt,
+		UpdatedAt: updatedAt,
+		IsSmart:   true,
+	}
+
+	s.emitEvent(events.PlaylistCreated, summary)
+
+	return summary, nil
+}
+
+// UpdateSmartPlaylistRules updates the rule set for an existing
+// smart playlist. Returns an error if the playlist does not exist
+// or is not a smart playlist.
+func (s *Service) UpdateSmartPlaylistRules(
+	playlistID int64,
+	rulesJSON string,
+) error {
+	// Validate rules JSON before storing.
+	if _, err := smartplaylist.ParseRuleSet(rulesJSON); err != nil {
+		return fmt.Errorf(
+			"invalid smart playlist rules: %w", err,
+		)
+	}
+
+	// SAFETY: Hand-crafted UPDATE for smart_rules column not
+	// yet in sqlc schema. All values are parameterized.
+	// Only updates rows where is_smart = 1.
+	result, err := s.db.ExecContext(
+		`UPDATE playlists
+		 SET smart_rules = ?, updated_at = CURRENT_TIMESTAMP
+		 WHERE id = ? AND is_smart = 1`,
+		rulesJSON, playlistID,
+	)
+	if err != nil {
+		s.logger.Error(
+			"Failed to update smart playlist rules",
+			"playlistId", playlistID, "err", err,
+		)
+
+		return fmt.Errorf(
+			"failed to update smart playlist rules: %w", err,
+		)
+	}
+
+	affected, err := result.RowsAffected()
+	if err != nil {
+		return fmt.Errorf(
+			"could not check rows affected: %w", err,
+		)
+	}
+
+	if affected == 0 {
+		return errNotSmartPlaylist
+	}
+
+	s.logger.Info(
+		"Smart playlist rules updated",
+		"playlistId", playlistID,
+	)
+
+	s.emitEvent(events.PlaylistTracksChanged, playlistID)
+
+	return nil
+}
+
+// EvaluateSmartPlaylist loads the rule set for a smart playlist
+// from the database and evaluates it against the track library,
+// returning the matching tracks.
+func (s *Service) EvaluateSmartPlaylist(
+	playlistID int64,
+) ([]library.Track, error) {
+	// SAFETY: Hand-crafted SELECT for smart_rules column not
+	// yet in sqlc schema. Parameterized by playlist ID.
+	rows, err := s.db.QueryContext(
+		`SELECT smart_rules FROM playlists
+		 WHERE id = ? AND is_smart = 1`,
+		playlistID,
+	)
+	if err != nil {
+		return nil, fmt.Errorf(
+			"failed to load smart playlist rules: %w", err,
+		)
+	}
+
+	if !rows.Next() {
+		_ = rows.Close()
+
+		return nil, errNotSmartPlaylist
+	}
+
+	var rulesJSON string
+
+	if err := rows.Scan(&rulesJSON); err != nil {
+		_ = rows.Close()
+
+		return nil, fmt.Errorf(
+			"failed to load smart playlist rules: %w", err,
+		)
+	}
+
+	// Close rows before calling Evaluate, which opens its own
+	// query. With MaxOpenConns=1 (test DBs), a deferred close
+	// would deadlock.
+	_ = rows.Close()
+
+	ruleSet, err := smartplaylist.ParseRuleSet(rulesJSON)
+	if err != nil {
+		return nil, fmt.Errorf(
+			"corrupt smart playlist rules for id %d: %w",
+			playlistID, err,
+		)
+	}
+
+	tracks, err := smartplaylist.Evaluate(s.db, ruleSet)
+	if err != nil {
+		return nil, fmt.Errorf(
+			"smart playlist evaluation failed for id %d: %w",
+			playlistID, err,
+		)
+	}
+
+	return tracks, nil
+}
+
+// PreviewSmartPlaylist evaluates a rule set from raw JSON without
+// requiring a saved playlist. This powers live preview in the rule
+// editor — the frontend sends rules as they are being edited and
+// receives matching tracks immediately.
+func (s *Service) PreviewSmartPlaylist(
+	rulesJSON string,
+) ([]library.Track, error) {
+	ruleSet, err := smartplaylist.ParseRuleSet(rulesJSON)
+	if err != nil {
+		return nil, fmt.Errorf(
+			"invalid smart playlist rules: %w", err,
+		)
+	}
+
+	tracks, err := smartplaylist.Evaluate(s.db, ruleSet)
+	if err != nil {
+		return nil, fmt.Errorf(
+			"smart playlist preview failed: %w", err,
+		)
+	}
+
+	s.logger.Info(
+		"Smart playlist preview evaluated",
+		"trackCount", len(tracks),
+	)
+
+	return tracks, nil
+}
+
+// GetSmartPlaylistRules returns the raw JSON rule string for an
+// existing smart playlist. This is used when the user opens the
+// rule editor for an existing smart playlist.
+func (s *Service) GetSmartPlaylistRules(
+	playlistID int64,
+) (string, error) {
+	// SAFETY: Hand-crafted SELECT for smart_rules column not
+	// yet in sqlc schema. Parameterized by playlist ID.
+	rows, err := s.db.QueryContext(
+		`SELECT smart_rules FROM playlists
+		 WHERE id = ? AND is_smart = 1`,
+		playlistID,
+	)
+	if err != nil {
+		return "", fmt.Errorf(
+			"failed to load smart playlist rules: %w", err,
+		)
+	}
+
+	defer func() { _ = rows.Close() }()
+
+	if !rows.Next() {
+		return "", errNotSmartPlaylist
+	}
+
+	var rulesJSON string
+
+	if err := rows.Scan(&rulesJSON); err != nil {
+		return "", fmt.Errorf(
+			"failed to scan smart playlist rules: %w", err,
+		)
+	}
+
+	s.logger.Info(
+		"Smart playlist rules loaded",
+		"playlistId", playlistID,
+	)
+
+	return rulesJSON, nil
+}
@@ -0,0 +1,665 @@
+package playlist
+
+import (
+	"encoding/json"
+	"log/slog"
+	"testing"
+
+	"yellowjacket/backend/database"
+	"yellowjacket/backend/smartplaylist"
+)
+
+// ---------------------------------------------------------------------------
+// Test helpers — seed data
+// ---------------------------------------------------------------------------
+
+// seedSmartTestTracks inserts a minimal set of tracks with the full
+// FK chain required for smart playlist evaluation tests.
+//
+//	ID 1: "Electric Song"  by "Band A"  album "Album One" (2020) genre=Rock    duration=300000ms
+//	ID 2: "Acoustic Vibes" by "Band B"  album "Album Two" (2015) genre=Jazz    duration=240000ms
+//	ID 3: "Heavy Metal"    by "Band A"  album "Album One" (2020) genre=Metal   duration=420000ms
+func seedSmartTestTracks(t *testing.T, db *database.DB) {
+	t.Helper()
+
+	type track struct {
+		id       int64
+		filePath string
+		title    string
+		artist   string
+		album    string
+		year     int64
+		genre    string
+		lenMs    int64
+	}
+
+	tracks := []track{
+		{
+			1, "/music/band_a/electric.mp3",
+			"Electric Song", "Band A", "Album One",
+			2020, "Rock", 300000,
+		},
+		{
+			2, "/music/band_b/acoustic.flac",
+			"Acoustic Vibes", "Band B", "Album Two",
+			2015, "Jazz", 240000,
+		},
+		{
+			3, "/music/band_a/heavy.mp3",
+			"Heavy Metal", "Band A", "Album One",
+			2020, "Metal", 420000,
+		},
+	}
+
+	// Build unique sets for artist_credit and release_groups.
+	artistMap := map[string]int64{}
+	albumMap := map[string]int64{}
+
+	var artistID, albumID int64
+
+	for _, tr := range tracks {
+		if _, ok := artistMap[tr.artist]; !ok {
+			artistID++
+			artistMap[tr.artist] = artistID
+		}
+
+		if _, ok := albumMap[tr.album]; !ok {
+			albumID++
+			albumMap[tr.album] = albumID
+		}
+	}
+
+	// Insert artist_credit rows.
+	for text, id := range artistMap {
+		_, err := db.ExecContext(
+			"INSERT INTO artist_credit (id, text) VALUES (?, ?)",
+			id, text,
+		)
+		if err != nil {
+			t.Fatalf("insert artist_credit %q: %v", text, err)
+		}
+	}
+
+	// Insert release_groups.
+	for name, id := range albumMap {
+		_, err := db.ExecContext(
+			"INSERT INTO release_groups (id, name) VALUES (?, ?)",
+			id, name,
+		)
+		if err != nil {
+			t.Fatalf("insert release_group %q: %v", name, err)
+		}
+	}
+
+	// Insert genres.
+	genreMap := map[string]int64{}
+
+	var genreID int64
+
+	for _, tr := range tracks {
+		if _, ok := genreMap[tr.genre]; !ok {
+			genreID++
+			genreMap[tr.genre] = genreID
+
+			_, err := db.ExecContext(
+				"INSERT INTO genres (id, name) VALUES (?, ?)",
+				genreID, tr.genre,
+			)
+			if err != nil {
+				t.Fatalf("insert genre %q: %v", tr.genre, err)
+			}
+		}
+	}
+
+	// Insert tracks with full FK chain.
+	for _, tr := range tracks {
+		acID := artistMap[tr.artist]
+		rgID := albumMap[tr.album]
+
+		// Insert recording.
+		_, err := db.ExecContext(
+			"INSERT INTO recordings (id, name, artist_credit_id, year) "+
+				"VALUES (?, ?, ?, ?)",
+			tr.id, tr.title, acID, tr.year,
+		)
+		if err != nil {
+			t.Fatalf("insert recording %d %q: %v", tr.id, tr.title, err)
+		}
+
+		// Insert audio_file.
+		_, err = db.ExecContext(
+			"INSERT INTO audio_files (id, file_path, "+
+				"length_milliseconds, file_type_id, recording_id, "+
+				"sample_rate, bit_depth, channels, bitrate, file_size) "+
+				"VALUES (?, ?, ?, 0, ?, 44100, 16, 2, 320000, 5000000)",
+			tr.id, tr.filePath, tr.lenMs, tr.id,
+		)
+		if err != nil {
+			t.Fatalf("insert audio_file %d: %v", tr.id, err)
+		}
+
+		// Link recording to release_group.
+		_, err = db.ExecContext(
+			"INSERT INTO release_group_recordings "+
+				"(release_group_id, recording_id) VALUES (?, ?)",
+			rgID, tr.id,
+		)
+		if err != nil {
+			t.Fatalf("insert release_group_recordings %d→%d: %v",
+				rgID, tr.id, err)
+		}
+
+		// Insert recording_genres link.
+		gID := genreMap[tr.genre]
+
+		_, err = db.ExecContext(
+			"INSERT INTO recording_genres "+
+				"(recording_id, genre_id) VALUES (?, ?)",
+			tr.id, gID,
+		)
+		if err != nil {
+			t.Fatalf("insert recording_genres %d→%d: %v",
+				tr.id, gID, err)
+		}
+	}
+}
+
+// newTestService constructs a playlist.Service with only the
+// fields needed for smart playlist operations (db and logger).
+func newTestService(t *testing.T, db *database.DB) *Service {
+	t.Helper()
+
+	return &Service{
+		db:     db,
+		logger: slog.Default(),
+	}
+}
+
+// makeRulesJSON is a helper that marshals rules into a valid JSON
+// string for use in tests.
+func makeRulesJSON(t *testing.T, rules smartplaylist.RuleSet) string {
+	t.Helper()
+
+	data, err := json.Marshal(rules)
+	if err != nil {
+		t.Fatalf("could not marshal rules: %v", err)
+	}
+
+	return string(data)
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+func TestSmartPlaylistCreateAndEvaluate(t *testing.T) {
+	t.Parallel()
+
+	db := database.NewTestDB(t)
+	seedSmartTestTracks(t, db)
+
+	svc := newTestService(t, db)
+
+	rulesJSON := makeRulesJSON(t, smartplaylist.RuleSet{
+		Rules: []smartplaylist.Rule{
+			{Field: "artist", Operator: "is", Value: "Band A"},
+		},
+	})
+
+	// Create smart playlist.
+	summary, err := svc.CreateSmartPlaylist("My Smart PL", rulesJSON)
+	if err != nil {
+		t.Fatalf("CreateSmartPlaylist failed: %v", err)
+	}
+
+	if summary.Name != "My Smart PL" {
+		t.Errorf("Name = %q, want %q", summary.Name, "My Smart PL")
+	}
+
+	if summary.ID <= 0 {
+		t.Errorf("ID = %d, want > 0", summary.ID)
+	}
+
+	if summary.CreatedAt == "" {
+		t.Error("CreatedAt is empty")
+	}
+
+	if summary.UpdatedAt == "" {
+		t.Error("UpdatedAt is empty")
+	}
+
+	// Evaluate the smart playlist.
+	tracks, err := svc.EvaluateSmartPlaylist(summary.ID)
+	if err != nil {
+		t.Fatalf("EvaluateSmartPlaylist failed: %v", err)
+	}
+
+	// Band A has tracks 1 and 3.
+	if len(tracks) != 2 {
+		t.Fatalf("got %d tracks, want 2", len(tracks))
+	}
+
+	// Verify tracks belong to Band A.
+	for _, tr := range tracks {
+		if tr.ArtistName != "Band A" {
+			t.Errorf("track %q has artist %q, want Band A",
+				tr.TrackName, tr.ArtistName)
+		}
+	}
+}
+
+func TestSmartPlaylistUpdateRules(t *testing.T) {
+	t.Parallel()
+
+	db := database.NewTestDB(t)
+	seedSmartTestTracks(t, db)
+
+	svc := newTestService(t, db)
+
+	// Create with artist filter for Band A (2 tracks).
+	initialRules := makeRulesJSON(t, smartplaylist.RuleSet{
+		Rules: []smartplaylist.Rule{
+			{Field: "artist", Operator: "is", Value: "Band A"},
+		},
+	})
+
+	summary, err := svc.CreateSmartPlaylist("Update Test", initialRules)
+	if err != nil {
+		t.Fatalf("CreateSmartPlaylist failed: %v", err)
+	}
+
+	// Update to artist = Band B (1 track).
+	newRules := makeRulesJSON(t, smartplaylist.RuleSet{
+		Rules: []smartplaylist.Rule{
+			{Field: "artist", Operator: "is", Value: "Band B"},
+		},
+	})
+
+	if err := svc.UpdateSmartPlaylistRules(summary.ID, newRules); err != nil {
+		t.Fatalf("UpdateSmartPlaylistRules failed: %v", err)
+	}
+
+	// Evaluate — should now return only Band B tracks.
+	tracks, err := svc.EvaluateSmartPlaylist(summary.ID)
+	if err != nil {
+		t.Fatalf("EvaluateSmartPlaylist failed: %v", err)
+	}
+
+	if len(tracks) != 1 {
+		t.Fatalf("got %d tracks, want 1", len(tracks))
+	}
+
+	if tracks[0].ArtistName != "Band B" {
+		t.Errorf("artist = %q, want Band B", tracks[0].ArtistName)
+	}
+}
+
+func TestSmartPlaylistCreateInvalidJSON(t *testing.T) {
+	t.Parallel()
+
+	db := database.NewTestDB(t)
+	svc := newTestService(t, db)
+
+	_, err := svc.CreateSmartPlaylist("Bad", "not json")
+	if err == nil {
+		t.Fatal("expected error for invalid JSON, got nil")
+	}
+}
+
+func TestSmartPlaylistCreateEmptyName(t *testing.T) {
+	t.Parallel()
+
+	db := database.NewTestDB(t)
+	svc := newTestService(t, db)
+
+	rulesJSON := makeRulesJSON(t, smartplaylist.RuleSet{
+		Rules: []smartplaylist.Rule{
+			{Field: "title", Operator: "contains", Value: "test"},
+		},
+	})
+
+	_, err := svc.CreateSmartPlaylist("", rulesJSON)
+	if err == nil {
+		t.Fatal("expected error for empty name, got nil")
+	}
+}
+
+func TestSmartPlaylistEvaluateNonSmartPlaylist(t *testing.T) {
+	t.Parallel()
+
+	db := database.NewTestDB(t)
+	svc := newTestService(t, db)
+
+	// Create a regular playlist via direct SQL.
+	// SAFETY: Test-only insert for regular playlist.
+	rows, err := db.QueryContext(
+		`INSERT INTO playlists (name) VALUES (?)
+		 RETURNING id`,
+		"Regular PL",
+	)
+	if err != nil {
+		t.Fatalf("insert regular playlist: %v", err)
+	}
+
+	var regularID int64
+	if rows.Next() {
+		if err := rows.Scan(&regularID); err != nil {
+			t.Fatalf("scan regular playlist id: %v", err)
+		}
+	}
+
+	_ = rows.Close()
+
+	// Evaluate should fail — not a smart playlist.
+	_, err = svc.EvaluateSmartPlaylist(regularID)
+	if err == nil {
+		t.Fatal("expected error evaluating non-smart playlist, got nil")
+	}
+}
+
+func TestSmartPlaylistEvaluateNonExistent(t *testing.T) {
+	t.Parallel()
+
+	db := database.NewTestDB(t)
+	svc := newTestService(t, db)
+
+	// Evaluate a playlist ID that doesn't exist.
+	_, err := svc.EvaluateSmartPlaylist(99999)
+	if err == nil {
+		t.Fatal("expected error evaluating non-existent playlist, got nil")
+	}
+}
+
+func TestSmartPlaylistUpdateNonSmartPlaylist(t *testing.T) {
+	t.Parallel()
+
+	db := database.NewTestDB(t)
+	svc := newTestService(t, db)
+
+	// Create a regular playlist.
+	rows, err := db.QueryContext(
+		`INSERT INTO playlists (name) VALUES (?)
+		 RETURNING id`,
+		"Regular PL",
+	)
+	if err != nil {
+		t.Fatalf("insert regular playlist: %v", err)
+	}
+
+	var regularID int64
+	if rows.Next() {
+		if err := rows.Scan(&regularID); err != nil {
+			t.Fatalf("scan regular playlist id: %v", err)
+		}
+	}
+
+	_ = rows.Close()
+
+	rulesJSON := makeRulesJSON(t, smartplaylist.RuleSet{
+		Rules: []smartplaylist.Rule{
+			{Field: "title", Operator: "contains", Value: "test"},
+		},
+	})
+
+	// Update should fail — not a smart playlist.
+	err = svc.UpdateSmartPlaylistRules(regularID, rulesJSON)
+	if err == nil {
+		t.Fatal("expected error updating non-smart playlist, got nil")
+	}
+}
+
+func TestSmartPlaylistUpdateInvalidJSON(t *testing.T) {
+	t.Parallel()
+
+	db := database.NewTestDB(t)
+	svc := newTestService(t, db)
+
+	// Create a real smart playlist first.
+	rulesJSON := makeRulesJSON(t, smartplaylist.RuleSet{
+		Rules: []smartplaylist.Rule{
+			{Field: "title", Operator: "contains", Value: "test"},
+		},
+	})
+
+	summary, err := svc.CreateSmartPlaylist("Valid PL", rulesJSON)
+	if err != nil {
+		t.Fatalf("CreateSmartPlaylist failed: %v", err)
+	}
+
+	// Update with invalid JSON.
+	err = svc.UpdateSmartPlaylistRules(summary.ID, "bad json")
+	if err == nil {
+		t.Fatal("expected error for invalid JSON update, got nil")
+	}
+}
+
+func TestSmartPlaylistGenreEvaluation(t *testing.T) {
+	t.Parallel()
+
+	db := database.NewTestDB(t)
+	seedSmartTestTracks(t, db)
+
+	svc := newTestService(t, db)
+
+	rulesJSON := makeRulesJSON(t, smartplaylist.RuleSet{
+		Rules: []smartplaylist.Rule{
+			{Field: "genre", Operator: "is", Value: "Rock"},
+		},
+	})
+
+	summary, err := svc.CreateSmartPlaylist("Genre Test", rulesJSON)
+	if err != nil {
+		t.Fatalf("CreateSmartPlaylist failed: %v", err)
+	}
+
+	tracks, err := svc.EvaluateSmartPlaylist(summary.ID)
+	if err != nil {
+		t.Fatalf("EvaluateSmartPlaylist failed: %v", err)
+	}
+
+	// Only track 1 ("Electric Song") has genre exactly "Rock".
+	if len(tracks) != 1 {
+		t.Fatalf("got %d tracks, want 1", len(tracks))
+	}
+
+	if tracks[0].TrackName != "Electric Song" {
+		t.Errorf("track = %q, want Electric Song", tracks[0].TrackName)
+	}
+}
+
+func TestSmartPlaylistYearNumericFilter(t *testing.T) {
+	t.Parallel()
+
+	db := database.NewTestDB(t)
+	seedSmartTestTracks(t, db)
+
+	svc := newTestService(t, db)
+
+	rulesJSON := makeRulesJSON(t, smartplaylist.RuleSet{
+		Rules: []smartplaylist.Rule{
+			{Field: "year", Operator: "greater_than", Value: "2019"},
+		},
+	})
+
+	summary, err := svc.CreateSmartPlaylist("Year Test", rulesJSON)
+	if err != nil {
+		t.Fatalf("CreateSmartPlaylist failed: %v", err)
+	}
+
+	tracks, err := svc.EvaluateSmartPlaylist(summary.ID)
+	if err != nil {
+		t.Fatalf("EvaluateSmartPlaylist failed: %v", err)
+	}
+
+	// Tracks 1 and 3 have year=2020, track 2 has year=2015.
+	if len(tracks) != 2 {
+		t.Fatalf("got %d tracks, want 2", len(tracks))
+	}
+
+	for _, tr := range tracks {
+		if tr.Year <= 2019 {
+			t.Errorf("track %q has year %d, want > 2019",
+				tr.TrackName, tr.Year)
+		}
+	}
+}
+
+// ---------------------------------------------------------------------------
+// Preview and GetRules tests
+// ---------------------------------------------------------------------------
+
+func TestSmartPlaylistPreview(t *testing.T) {
+	t.Parallel()
+
+	db := database.NewTestDB(t)
+	seedSmartTestTracks(t, db)
+
+	svc := newTestService(t, db)
+
+	rulesJSON := makeRulesJSON(t, smartplaylist.RuleSet{
+		Rules: []smartplaylist.Rule{
+			{Field: "artist", Operator: "is", Value: "Band A"},
+		},
+	})
+
+	// Create and evaluate via saved playlist for comparison.
+	summary, err := svc.CreateSmartPlaylist("Preview Compare", rulesJSON)
+	if err != nil {
+		t.Fatalf("CreateSmartPlaylist failed: %v", err)
+	}
+
+	savedTracks, err := svc.EvaluateSmartPlaylist(summary.ID)
+	if err != nil {
+		t.Fatalf("EvaluateSmartPlaylist failed: %v", err)
+	}
+
+	// Preview with same rules — should return same tracks.
+	previewTracks, err := svc.PreviewSmartPlaylist(rulesJSON)
+	if err != nil {
+		t.Fatalf("PreviewSmartPlaylist failed: %v", err)
+	}
+
+	if len(previewTracks) != len(savedTracks) {
+		t.Fatalf(
+			"preview returned %d tracks, saved returned %d",
+			len(previewTracks), len(savedTracks),
+		)
+	}
+
+	// Verify all preview tracks are Band A.
+	for _, tr := range previewTracks {
+		if tr.ArtistName != "Band A" {
+			t.Errorf(
+				"preview track %q has artist %q, want Band A",
+				tr.TrackName, tr.ArtistName,
+			)
+		}
+	}
+}
+
+func TestSmartPlaylistPreviewInvalidRules(t *testing.T) {
+	t.Parallel()
+
+	db := database.NewTestDB(t)
+	svc := newTestService(t, db)
+
+	_, err := svc.PreviewSmartPlaylist("not valid json")
+	if err == nil {
+		t.Fatal("expected error for invalid JSON, got nil")
+	}
+}
+
+func TestSmartPlaylistGetRules(t *testing.T) {
+	t.Parallel()
+
+	db := database.NewTestDB(t)
+	seedSmartTestTracks(t, db)
+
+	svc := newTestService(t, db)
+
+	rulesJSON := makeRulesJSON(t, smartplaylist.RuleSet{
+		Rules: []smartplaylist.Rule{
+			{Field: "genre", Operator: "is", Value: "Rock"},
+		},
+	})
+
+	summary, err := svc.CreateSmartPlaylist("Get Rules Test", rulesJSON)
+	if err != nil {
+		t.Fatalf("CreateSmartPlaylist failed: %v", err)
+	}
+
+	got, err := svc.GetSmartPlaylistRules(summary.ID)
+	if err != nil {
+		t.Fatalf("GetSmartPlaylistRules failed: %v", err)
+	}
+
+	if got != rulesJSON {
+		t.Errorf(
+			"GetSmartPlaylistRules = %q, want %q",
+			got, rulesJSON,
+		)
+	}
+}
+
+func TestSmartPlaylistGetRulesNotFound(t *testing.T) {
+	t.Parallel()
+
+	db := database.NewTestDB(t)
+	svc := newTestService(t, db)
+
+	_, err := svc.GetSmartPlaylistRules(99999)
+	if err == nil {
+		t.Fatal(
+			"expected error for non-existent playlist, got nil",
+		)
+	}
+
+	if err.Error() != errNotSmartPlaylist.Error() {
+		t.Errorf(
+			"error = %q, want %q",
+			err.Error(), errNotSmartPlaylist.Error(),
+		)
+	}
+}
+
+func TestSmartPlaylistGetRulesRegularPlaylist(t *testing.T) {
+	t.Parallel()
+
+	db := database.NewTestDB(t)
+	svc := newTestService(t, db)
+
+	// Create a regular playlist via direct SQL.
+	// SAFETY: Test-only insert for regular playlist.
+	rows, err := db.QueryContext(
+		`INSERT INTO playlists (name) VALUES (?)
+		 RETURNING id`,
+		"Regular PL For GetRules",
+	)
+	if err != nil {
+		t.Fatalf("insert regular playlist: %v", err)
+	}
+
+	var regularID int64
+	if rows.Next() {
+		if err := rows.Scan(&regularID); err != nil {
+			t.Fatalf("scan regular playlist id: %v", err)
+		}
+	}
+
+	_ = rows.Close()
+
+	// GetSmartPlaylistRules should fail — not a smart playlist.
+	_, err = svc.GetSmartPlaylistRules(regularID)
+	if err == nil {
+		t.Fatal(
+			"expected error for regular playlist, got nil",
+		)
+	}
+
+	if err.Error() != errNotSmartPlaylist.Error() {
+		t.Errorf(
+			"error = %q, want %q",
+			err.Error(), errNotSmartPlaylist.Error(),
+		)
+	}
+}