refactor: model behavioral interface

internal/handlers/books_test.go

···
 				defer handler.Close()
 
 				ctx := context.Background()
-				if _, err = handler.repos.Books.Create(ctx, &models.Book{
-					Title:  "Interactive Test Book",
-					Author: "Interactive Author",
-					Status: "completed",
-				}); err != nil {
+				if _, err = handler.repos.Books.Create(ctx,
+					&models.Book{
+						Title: "Interactive Test Book", Author: "Interactive Author", Status: "finished",
+					}); err != nil {
 					t.Fatalf("Failed to create test book: %v", err)
 				}
 

internal/models/behaviors.go

···
+package models
+
+import "time"
+
+// Stateful represents entities with status management behavior
+//
+// Implemented by: [Book], [Movie], [TVShow], [Task]
+type Stateful interface {
+	GetStatus() string
+	ValidStatuses() []string
+}
+
+// Queueable represents media that can be queued for later consumption
+//
+// Implemented by: [Book], [Movie], [TVShow]
+type Queueable interface {
+	Stateful
+	IsQueued() bool
+}
+
+// Completable represents media that can be marked as completed/finished/watched. It tracks completion timestamps for media consumption.
+//
+// Implemented by: [Book] (finished), [Movie] (watched), [TVShow] (watched)
+type Completable interface {
+	Stateful
+	IsCompleted() bool
+	GetCompletionTime() *time.Time
+}
+
+// Progressable represents media with measurable progress tracking
+//
+// Implemented by: [Book] (percentage-based reading progress)
+type Progressable interface {
+	Completable
+	GetProgress() int
+	SetProgress(progress int) error
+}
+
+// Compile-time interface checks
+var (
+	_ Stateful     = (*Task)(nil)
+	_ Stateful     = (*Book)(nil)
+	_ Stateful     = (*Movie)(nil)
+	_ Stateful     = (*TVShow)(nil)
+	_ Queueable    = (*Book)(nil)
+	_ Queueable    = (*Movie)(nil)
+	_ Queueable    = (*TVShow)(nil)
+	_ Completable  = (*Book)(nil)
+	_ Completable  = (*Movie)(nil)
+	_ Completable  = (*TVShow)(nil)
+	_ Progressable = (*Book)(nil)
+)

internal/models/models.go

···
 
 import (
 	"encoding/json"
+	"fmt"
 	"net/url"
 	"slices"
 	"time"
···
 }
 
 // IsStarted returns true if the task has a start time set.
-func (t *Task) IsStarted() bool {
-	return t.Start != nil
-}
+func (t *Task) IsStarted() bool { return t.Start != nil }
 
 // IsOverdue returns true if the task is overdue.
 func (t *Task) IsOverdue(now time.Time) bool {
···
 }
 
 // HasDueDate returns true if the task has a due date set.
-func (t *Task) HasDueDate() bool {
-	return t.Due != nil
-}
+func (t *Task) HasDueDate() bool { return t.Due != nil }
 
 // IsRecurring returns true if the task has recurrence defined.
-func (t *Task) IsRecurring() bool {
-	return t.Recur != ""
-}
+func (t *Task) IsRecurring() bool { return t.Recur != "" }
 
 // IsRecurExpired checks if the recurrence has an end (until) date and is past it.
 func (t *Task) IsRecurExpired(now time.Time) bool {
···
 }
 
 // HasDependencies returns true if the task depends on other tasks.
-func (t *Task) HasDependencies() bool {
-	return len(t.DependsOn) > 0
-}
+func (t *Task) HasDependencies() bool { return len(t.DependsOn) > 0 }
 
 // Blocks checks if this task blocks another given task.
 func (t *Task) Blocks(other *Task) bool {
···
 	return score
 }
 
+// GetStatus returns the current status of the task
+func (t *Task) GetStatus() string { return t.Status }
+
+// ValidStatuses returns all valid status values for a task
+func (t *Task) ValidStatuses() []string {
+	return []string{
+		StatusTodo, StatusInProgress, StatusBlocked, StatusDone, StatusAbandoned,
+		StatusPending, StatusCompleted, StatusDeleted,
+	}
+}
+
 // IsWatched returns true if the movie has been watched
-func (m *Movie) IsWatched() bool {
-	return m.Status == "watched"
-}
+func (m *Movie) IsWatched() bool { return m.Status == "watched" }
 
 // IsQueued returns true if the movie is in the queue
-func (m *Movie) IsQueued() bool {
-	return m.Status == "queued"
-}
+func (m *Movie) IsQueued() bool { return m.Status == "queued" }
+
+// GetStatus returns the current status of the movie
+func (m *Movie) GetStatus() string { return m.Status }
+
+// ValidStatuses returns all valid status values for a movie
+func (m *Movie) ValidStatuses() []string { return []string{"queued", "watched", "removed"} }
+
+// IsCompleted returns true if the movie has been watched
+func (m *Movie) IsCompleted() bool { return m.Status == "watched" }
+
+// GetCompletionTime returns when the movie was watched
+func (m *Movie) GetCompletionTime() *time.Time { return m.Watched }
 
 // IsWatching returns true if the TV show is currently being watched
-func (tv *TVShow) IsWatching() bool {
-	return tv.Status == "watching"
-}
+func (tv *TVShow) IsWatching() bool { return tv.Status == "watching" }
 
 // IsWatched returns true if the TV show has been watched
-func (tv *TVShow) IsWatched() bool {
-	return tv.Status == "watched"
-}
+func (tv *TVShow) IsWatched() bool { return tv.Status == "watched" }
 
 // IsQueued returns true if the TV show is in the queue
-func (tv *TVShow) IsQueued() bool {
-	return tv.Status == "queued"
+func (tv *TVShow) IsQueued() bool { return tv.Status == "queued" }
+
+// GetStatus returns the current status of the TV show
+func (tv *TVShow) GetStatus() string { return tv.Status }
+
+// ValidStatuses returns all valid status values for a TV show
+func (tv *TVShow) ValidStatuses() []string {
+	return []string{"queued", "watching", "watched", "removed"}
 }
 
+// IsCompleted returns true if the TV show has been watched
+func (tv *TVShow) IsCompleted() bool { return tv.Status == "watched" }
+
+// GetCompletionTime returns when the TV show was last watched
+func (tv *TVShow) GetCompletionTime() *time.Time { return tv.LastWatched }
+
 // IsReading returns true if the book is currently being read
-func (b *Book) IsReading() bool {
-	return b.Status == "reading"
-}
+func (b *Book) IsReading() bool { return b.Status == "reading" }
 
 // IsFinished returns true if the book has been finished
-func (b *Book) IsFinished() bool {
-	return b.Status == "finished"
-}
+func (b *Book) IsFinished() bool { return b.Status == "finished" }
 
 // IsQueued returns true if the book is in the queue
-func (b *Book) IsQueued() bool {
-	return b.Status == "queued"
-}
+func (b *Book) IsQueued() bool { return b.Status == "queued" }
 
 // ProgressPercent returns the reading progress as a percentage
-func (b *Book) ProgressPercent() int {
-	return b.Progress
+func (b *Book) ProgressPercent() int { return b.Progress }
+
+// GetStatus returns the current status of the book
+func (b *Book) GetStatus() string { return b.Status }
+
+// ValidStatuses returns all valid status values for a book
+func (b *Book) ValidStatuses() []string { return []string{"queued", "reading", "finished", "removed"} }
+
+// IsCompleted returns true if the book has been finished
+func (b *Book) IsCompleted() bool { return b.Status == "finished" }
+
+// GetCompletionTime returns when the book was finished
+func (b *Book) GetCompletionTime() *time.Time { return b.Finished }
+
+// GetProgress returns the reading progress percentage (0-100)
+func (b *Book) GetProgress() int { return b.Progress }
+
+// SetProgress sets the reading progress percentage (0-100)
+func (b *Book) SetProgress(progress int) error {
+	if progress < 0 || progress > 100 {
+		return fmt.Errorf("progress must be between 0 and 100, got %d", progress)
+	}
+	b.Progress = progress
+	return nil
 }
 
 func (t *Task) GetID() int64                { return t.ID }

internal/models/models_test.go

···
 			}
 		})
 	})
+
+	t.Run("Behavior Interfaces", func(t *testing.T) {
+		t.Run("Stateful Interface", func(t *testing.T) {
+			t.Run("Task implements Stateful", func(t *testing.T) {
+				task := &Task{Status: StatusTodo}
+
+				if task.GetStatus() != StatusTodo {
+					t.Errorf("Expected status %s, got %s", StatusTodo, task.GetStatus())
+				}
+
+				validStatuses := task.ValidStatuses()
+				if len(validStatuses) == 0 {
+					t.Error("ValidStatuses should not be empty")
+				}
+
+				expectedStatuses := []string{StatusTodo, StatusInProgress, StatusBlocked, StatusDone, StatusAbandoned, StatusPending, StatusCompleted, StatusDeleted}
+				if len(validStatuses) != len(expectedStatuses) {
+					t.Errorf("Expected %d valid statuses, got %d", len(expectedStatuses), len(validStatuses))
+				}
+			})
+
+			t.Run("Book implements Stateful", func(t *testing.T) {
+				book := &Book{Status: "reading"}
+
+				if book.GetStatus() != "reading" {
+					t.Errorf("Expected status 'reading', got %s", book.GetStatus())
+				}
+
+				validStatuses := book.ValidStatuses()
+				expectedStatuses := []string{"queued", "reading", "finished", "removed"}
+
+				if len(validStatuses) != len(expectedStatuses) {
+					t.Errorf("Expected %d valid statuses, got %d", len(expectedStatuses), len(validStatuses))
+				}
+
+				for i, status := range expectedStatuses {
+					if validStatuses[i] != status {
+						t.Errorf("Expected status %s at index %d, got %s", status, i, validStatuses[i])
+					}
+				}
+			})
+
+			t.Run("Movie implements Stateful", func(t *testing.T) {
+				movie := &Movie{Status: "queued"}
+
+				if movie.GetStatus() != "queued" {
+					t.Errorf("Expected status 'queued', got %s", movie.GetStatus())
+				}
+
+				validStatuses := movie.ValidStatuses()
+				expectedStatuses := []string{"queued", "watched", "removed"}
+
+				if len(validStatuses) != len(expectedStatuses) {
+					t.Errorf("Expected %d valid statuses, got %d", len(expectedStatuses), len(validStatuses))
+				}
+			})
+
+			t.Run("TVShow implements Stateful", func(t *testing.T) {
+				tvShow := &TVShow{Status: "watching"}
+
+				if tvShow.GetStatus() != "watching" {
+					t.Errorf("Expected status 'watching', got %s", tvShow.GetStatus())
+				}
+
+				validStatuses := tvShow.ValidStatuses()
+				expectedStatuses := []string{"queued", "watching", "watched", "removed"}
+
+				if len(validStatuses) != len(expectedStatuses) {
+					t.Errorf("Expected %d valid statuses, got %d", len(expectedStatuses), len(validStatuses))
+				}
+			})
+		})
+
+		t.Run("Completable Interface", func(t *testing.T) {
+			t.Run("Book implements Completable", func(t *testing.T) {
+				now := time.Now()
+
+				unfinishedBook := &Book{Status: "reading"}
+				if unfinishedBook.IsCompleted() {
+					t.Error("Book with 'reading' status should not be completed")
+				}
+				if unfinishedBook.GetCompletionTime() != nil {
+					t.Error("Unfinished book should have nil completion time")
+				}
+
+				finishedBook := &Book{Status: "finished", Finished: &now}
+				if !finishedBook.IsCompleted() {
+					t.Error("Book with 'finished' status should be completed")
+				}
+				if finishedBook.GetCompletionTime() == nil {
+					t.Error("Finished book should have completion time")
+				}
+				if !finishedBook.GetCompletionTime().Equal(now) {
+					t.Errorf("Expected completion time %v, got %v", now, finishedBook.GetCompletionTime())
+				}
+			})
+
+			t.Run("Movie implements Completable", func(t *testing.T) {
+				now := time.Now()
+
+				unwatchedMovie := &Movie{Status: "queued"}
+				if unwatchedMovie.IsCompleted() {
+					t.Error("Movie with 'queued' status should not be completed")
+				}
+				if unwatchedMovie.GetCompletionTime() != nil {
+					t.Error("Unwatched movie should have nil completion time")
+				}
+
+				watchedMovie := &Movie{Status: "watched", Watched: &now}
+				if !watchedMovie.IsCompleted() {
+					t.Error("Movie with 'watched' status should be completed")
+				}
+				if watchedMovie.GetCompletionTime() == nil {
+					t.Error("Watched movie should have completion time")
+				}
+				if !watchedMovie.GetCompletionTime().Equal(now) {
+					t.Errorf("Expected completion time %v, got %v", now, watchedMovie.GetCompletionTime())
+				}
+			})
+
+			t.Run("TVShow implements Completable", func(t *testing.T) {
+				now := time.Now()
+
+				unwatchedShow := &TVShow{Status: "watching"}
+				if unwatchedShow.IsCompleted() {
+					t.Error("TVShow with 'watching' status should not be completed")
+				}
+				if unwatchedShow.GetCompletionTime() != nil {
+					t.Error("Unwatched show should have nil completion time")
+				}
+
+				watchedShow := &TVShow{Status: "watched", LastWatched: &now}
+				if !watchedShow.IsCompleted() {
+					t.Error("TVShow with 'watched' status should be completed")
+				}
+				if watchedShow.GetCompletionTime() == nil {
+					t.Error("Watched show should have completion time")
+				}
+				if !watchedShow.GetCompletionTime().Equal(now) {
+					t.Errorf("Expected completion time %v, got %v", now, watchedShow.GetCompletionTime())
+				}
+			})
+		})
+
+		t.Run("Progressable Interface", func(t *testing.T) {
+			t.Run("Book implements Progressable", func(t *testing.T) {
+				book := &Book{Progress: 50}
+
+				if book.GetProgress() != 50 {
+					t.Errorf("Expected progress 50, got %d", book.GetProgress())
+				}
+			})
+
+			t.Run("SetProgress with valid values", func(t *testing.T) {
+				book := &Book{}
+
+				if err := book.SetProgress(0); err != nil {
+					t.Errorf("SetProgress(0) should succeed, got error: %v", err)
+				}
+				if book.Progress != 0 {
+					t.Errorf("Expected progress 0, got %d", book.Progress)
+				}
+
+				if err := book.SetProgress(100); err != nil {
+					t.Errorf("SetProgress(100) should succeed, got error: %v", err)
+				}
+				if book.Progress != 100 {
+					t.Errorf("Expected progress 100, got %d", book.Progress)
+				}
+
+				if err := book.SetProgress(42); err != nil {
+					t.Errorf("SetProgress(42) should succeed, got error: %v", err)
+				}
+				if book.Progress != 42 {
+					t.Errorf("Expected progress 42, got %d", book.Progress)
+				}
+			})
+
+			t.Run("SetProgress rejects invalid values", func(t *testing.T) {
+				book := &Book{Progress: 50}
+
+				if err := book.SetProgress(-1); err == nil {
+					t.Error("SetProgress(-1) should fail")
+				} else if book.Progress != 50 {
+					t.Error("Progress should not change on validation error")
+				}
+
+				if err := book.SetProgress(101); err == nil {
+					t.Error("SetProgress(101) should fail")
+				} else if book.Progress != 50 {
+					t.Error("Progress should not change on validation error")
+				}
+
+				if err := book.SetProgress(-100); err == nil {
+					t.Error("SetProgress(-100) should fail")
+				}
+
+				if err := book.SetProgress(1000); err == nil {
+					t.Error("SetProgress(1000) should fail")
+				}
+			})
+
+			t.Run("SetProgress error messages", func(t *testing.T) {
+				book := &Book{}
+
+				err := book.SetProgress(-5)
+				if err == nil {
+					t.Fatal("Expected error for negative progress")
+				}
+				if err.Error() != "progress must be between 0 and 100, got -5" {
+					t.Errorf("Unexpected error message: %s", err.Error())
+				}
+
+				err = book.SetProgress(150)
+				if err == nil {
+					t.Fatal("Expected error for progress > 100")
+				}
+				if err.Error() != "progress must be between 0 and 100, got 150" {
+					t.Errorf("Unexpected error message: %s", err.Error())
+				}
+			})
+		})
+	})
 }

internal/repo/base_media_repository_test.go

···
+package repo
+
+import (
+	"context"
+	"testing"
+
+	_ "github.com/mattn/go-sqlite3"
+	"github.com/stormlightlabs/noteleaf/internal/models"
+)
+
+func TestBaseMediaRepository(t *testing.T) {
+	ctx := context.Background()
+
+	t.Run("Books", func(t *testing.T) {
+		t.Run("Create and Get", func(t *testing.T) {
+			db := CreateTestDB(t)
+			repo := NewBookRepository(db)
+
+			book := &models.Book{
+				Title:  "Test Book",
+				Author: "Test Author",
+				Status: "queued",
+			}
+
+			id, err := repo.Create(ctx, book)
+			AssertNoError(t, err, "Failed to create book")
+			AssertNotEqual(t, int64(0), id, "Expected non-zero ID")
+
+			retrieved, err := repo.Get(ctx, id)
+			AssertNoError(t, err, "Failed to get book")
+			AssertEqual(t, book.Title, retrieved.Title, "Title mismatch")
+			AssertEqual(t, book.Author, retrieved.Author, "Author mismatch")
+			AssertEqual(t, book.Status, retrieved.Status, "Status mismatch")
+		})
+
+		t.Run("Update", func(t *testing.T) {
+			db := CreateTestDB(t)
+			repo := NewBookRepository(db)
+
+			book := &models.Book{
+				Title:  "Original Title",
+				Author: "Original Author",
+				Status: "queued",
+			}
+
+			id, err := repo.Create(ctx, book)
+			AssertNoError(t, err, "Failed to create book")
+
+			book.Title = "Updated Title"
+			book.Author = "Updated Author"
+			book.Status = "reading"
+
+			err = repo.Update(ctx, book)
+			AssertNoError(t, err, "Failed to update book")
+
+			retrieved, err := repo.Get(ctx, id)
+			AssertNoError(t, err, "Failed to get updated book")
+			AssertEqual(t, "Updated Title", retrieved.Title, "Title not updated")
+			AssertEqual(t, "Updated Author", retrieved.Author, "Author not updated")
+			AssertEqual(t, "reading", retrieved.Status, "Status not updated")
+		})
+
+		t.Run("Delete", func(t *testing.T) {
+			db := CreateTestDB(t)
+			repo := NewBookRepository(db)
+
+			book := &models.Book{
+				Title:  "To Delete",
+				Status: "queued",
+			}
+
+			id, err := repo.Create(ctx, book)
+			AssertNoError(t, err, "Failed to create book")
+
+			err = repo.Delete(ctx, id)
+			AssertNoError(t, err, "Failed to delete book")
+
+			_, err = repo.Get(ctx, id)
+			AssertError(t, err, "Expected error when getting deleted book")
+		})
+
+		t.Run("Get non-existent", func(t *testing.T) {
+			db := CreateTestDB(t)
+			repo := NewBookRepository(db)
+
+			_, err := repo.Get(ctx, 9999)
+			AssertError(t, err, "Expected error for non-existent book")
+			AssertContains(t, err.Error(), "not found", "Error should mention 'not found'")
+		})
+
+		t.Run("ListQuery with multiple books", func(t *testing.T) {
+			db := CreateTestDB(t)
+			repo := NewBookRepository(db)
+
+			books := []*models.Book{
+				{Title: "Book 1", Author: "Author A", Status: "queued"},
+				{Title: "Book 2", Author: "Author B", Status: "reading"},
+				{Title: "Book 3", Author: "Author A", Status: "finished"},
+			}
+
+			for _, book := range books {
+				_, err := repo.Create(ctx, book)
+				AssertNoError(t, err, "Failed to create book")
+			}
+
+			allBooks, err := repo.List(ctx, BookListOptions{})
+			AssertNoError(t, err, "Failed to list books")
+			if len(allBooks) != 3 {
+				t.Errorf("Expected 3 books, got %d", len(allBooks))
+			}
+		})
+
+		t.Run("CountQuery", func(t *testing.T) {
+			db := CreateTestDB(t)
+			repo := NewBookRepository(db)
+
+			for i := 0; i < 5; i++ {
+				book := &models.Book{
+					Title:  "Book",
+					Status: "queued",
+				}
+				_, err := repo.Create(ctx, book)
+				AssertNoError(t, err, "Failed to create book")
+			}
+
+			count, err := repo.Count(ctx, BookListOptions{})
+			AssertNoError(t, err, "Failed to count books")
+			if count != 5 {
+				t.Errorf("Expected count of 5, got %d", count)
+			}
+		})
+	})
+
+	t.Run("Movies", func(t *testing.T) {
+		t.Run("Create and Get", func(t *testing.T) {
+			db := CreateTestDB(t)
+			repo := NewMovieRepository(db)
+
+			movie := &models.Movie{
+				Title:  "Test Movie",
+				Year:   2023,
+				Status: "queued",
+			}
+
+			id, err := repo.Create(ctx, movie)
+			AssertNoError(t, err, "Failed to create movie")
+			AssertNotEqual(t, int64(0), id, "Expected non-zero ID")
+
+			retrieved, err := repo.Get(ctx, id)
+			AssertNoError(t, err, "Failed to get movie")
+			AssertEqual(t, movie.Title, retrieved.Title, "Title mismatch")
+			AssertEqual(t, movie.Year, retrieved.Year, "Year mismatch")
+			AssertEqual(t, movie.Status, retrieved.Status, "Status mismatch")
+		})
+
+		t.Run("Update", func(t *testing.T) {
+			db := CreateTestDB(t)
+			repo := NewMovieRepository(db)
+
+			movie := &models.Movie{
+				Title:  "Original Movie",
+				Year:   2020,
+				Status: "queued",
+			}
+
+			id, err := repo.Create(ctx, movie)
+			AssertNoError(t, err, "Failed to create movie")
+
+			movie.Title = "Updated Movie"
+			movie.Year = 2023
+			movie.Status = "watched"
+
+			err = repo.Update(ctx, movie)
+			AssertNoError(t, err, "Failed to update movie")
+
+			retrieved, err := repo.Get(ctx, id)
+			AssertNoError(t, err, "Failed to get updated movie")
+			AssertEqual(t, "Updated Movie", retrieved.Title, "Title not updated")
+			AssertEqual(t, 2023, retrieved.Year, "Year not updated")
+			AssertEqual(t, "watched", retrieved.Status, "Status not updated")
+		})
+
+		t.Run("Delete", func(t *testing.T) {
+			db := CreateTestDB(t)
+			repo := NewMovieRepository(db)
+
+			movie := &models.Movie{
+				Title:  "To Delete",
+				Status: "queued",
+			}
+
+			id, err := repo.Create(ctx, movie)
+			AssertNoError(t, err, "Failed to create movie")
+
+			err = repo.Delete(ctx, id)
+			AssertNoError(t, err, "Failed to delete movie")
+
+			_, err = repo.Get(ctx, id)
+			AssertError(t, err, "Expected error when getting deleted movie")
+		})
+	})
+
+	t.Run("TV Shows", func(t *testing.T) {
+		t.Run("Create and Get", func(t *testing.T) {
+			db := CreateTestDB(t)
+			repo := NewTVRepository(db)
+
+			show := &models.TVShow{
+				Title:   "Test Show",
+				Season:  1,
+				Episode: 1,
+				Status:  "queued",
+			}
+
+			id, err := repo.Create(ctx, show)
+			AssertNoError(t, err, "Failed to create TV show")
+			AssertNotEqual(t, int64(0), id, "Expected non-zero ID")
+
+			retrieved, err := repo.Get(ctx, id)
+			AssertNoError(t, err, "Failed to get TV show")
+			AssertEqual(t, show.Title, retrieved.Title, "Title mismatch")
+			AssertEqual(t, show.Season, retrieved.Season, "Season mismatch")
+			AssertEqual(t, show.Episode, retrieved.Episode, "Episode mismatch")
+			AssertEqual(t, show.Status, retrieved.Status, "Status mismatch")
+		})
+
+		t.Run("Update", func(t *testing.T) {
+			db := CreateTestDB(t)
+			repo := NewTVRepository(db)
+
+			show := &models.TVShow{
+				Title:   "Original Show",
+				Season:  1,
+				Episode: 1,
+				Status:  "queued",
+			}
+
+			id, err := repo.Create(ctx, show)
+			AssertNoError(t, err, "Failed to create TV show")
+
+			show.Title = "Updated Show"
+			show.Season = 2
+			show.Episode = 5
+			show.Status = "watching"
+
+			err = repo.Update(ctx, show)
+			AssertNoError(t, err, "Failed to update TV show")
+
+			retrieved, err := repo.Get(ctx, id)
+			AssertNoError(t, err, "Failed to get updated TV show")
+			AssertEqual(t, "Updated Show", retrieved.Title, "Title not updated")
+			AssertEqual(t, 2, retrieved.Season, "Season not updated")
+			AssertEqual(t, 5, retrieved.Episode, "Episode not updated")
+			AssertEqual(t, "watching", retrieved.Status, "Status not updated")
+		})
+
+		t.Run("Delete", func(t *testing.T) {
+			db := CreateTestDB(t)
+			repo := NewTVRepository(db)
+
+			show := &models.TVShow{
+				Title:  "To Delete",
+				Status: "queued",
+			}
+
+			id, err := repo.Create(ctx, show)
+			AssertNoError(t, err, "Failed to create TV show")
+
+			err = repo.Delete(ctx, id)
+			AssertNoError(t, err, "Failed to delete TV show")
+
+			_, err = repo.Get(ctx, id)
+			AssertError(t, err, "Expected error when getting deleted TV show")
+		})
+	})
+
+	t.Run("Edge Cases", func(t *testing.T) {
+		t.Run("buildPlaceholders", func(t *testing.T) {
+			emptyResult := buildPlaceholders([]any{})
+			if emptyResult != "" {
+				t.Errorf("Expected empty string for empty values, got '%s'", emptyResult)
+			}
+
+			singleResult := buildPlaceholders([]any{1})
+			if singleResult != "?" {
+				t.Errorf("Expected '?' for single value, got '%s'", singleResult)
+			}
+
+			multipleResult := buildPlaceholders([]any{1, 2, 3})
+			if multipleResult != "?,?,?" {
+				t.Errorf("Expected '?,?,?' for three values, got '%s'", multipleResult)
+			}
+
+			largeResult := buildPlaceholders(make([]any, 10))
+			expected := "?,?,?,?,?,?,?,?,?,?"
+			if largeResult != expected {
+				t.Errorf("Expected '%s' for ten values, got '%s'", expected, largeResult)
+			}
+		})
+	})
+}

internal/repo/book_repository.go

···
 	"time"
 
 	"github.com/stormlightlabs/noteleaf/internal/models"
+	"github.com/stormlightlabs/noteleaf/internal/services"
 )
 
 // BookRepository provides database operations for books
 //
 // Uses BaseMediaRepository for common CRUD operations.
-// TODO: Implement Repository interface (Validate method) similar to ArticleRepository
 type BookRepository struct {
 	*BaseMediaRepository[*models.Book]
 	db *sql.DB
···
 		New:           func() *models.Book { return &models.Book{} },
 		InsertColumns: "title, author, status, progress, pages, rating, notes, added, started, finished",
 		UpdateColumns: "title = ?, author = ?, status = ?, progress = ?, pages = ?, rating = ?, notes = ?, started = ?, finished = ?",
+		Scan:          func(rows *sql.Rows, book *models.Book) error { return scanBookRow(rows, book) },
+		ScanSingle:    func(row *sql.Row, book *models.Book) error { return scanBookRowSingle(row, book) },
 		InsertValues: func(book *models.Book) []any {
 			return []any{book.Title, book.Author, book.Status, book.Progress, book.Pages, book.Rating, book.Notes, book.Added, book.Started, book.Finished}
 		},
 		UpdateValues: func(book *models.Book) []any {
 			return []any{book.Title, book.Author, book.Status, book.Progress, book.Pages, book.Rating, book.Notes, book.Started, book.Finished, book.ID}
-		},
-		Scan: func(rows *sql.Rows, book *models.Book) error {
-			return scanBookRow(rows, book)
-		},
-		ScanSingle: func(row *sql.Row, book *models.Book) error {
-			return scanBookRowSingle(row, book)
 		},
 	}
 
-	return &BookRepository{
-		BaseMediaRepository: NewBaseMediaRepository(db, config),
-		db:                  db,
-	}
+	return &BookRepository{BaseMediaRepository: NewBaseMediaRepository(db, config), db: db}
 }
 
 // Create stores a new book and returns its assigned ID
 func (r *BookRepository) Create(ctx context.Context, book *models.Book) (int64, error) {
+	if err := r.Validate(book); err != nil {
+		return 0, err
+	}
+
 	now := time.Now()
 	book.Added = now
 
···
 	return id, nil
 }
 
+// Update modifies an existing book
+func (r *BookRepository) Update(ctx context.Context, book *models.Book) error {
+	if err := r.Validate(book); err != nil {
+		return err
+	}
+	return r.BaseMediaRepository.Update(ctx, book)
+}
+
 // List retrieves books with optional filtering and sorting
 func (r *BookRepository) List(ctx context.Context, opts BookListOptions) ([]*models.Book, error) {
 	query := r.buildListQuery(opts)
 	args := r.buildListArgs(opts)
-
 	items, err := r.BaseMediaRepository.ListQuery(ctx, query, args...)
 	if err != nil {
 		return nil, err
···
 			query += fmt.Sprintf(" OFFSET %d", opts.Offset)
 		}
 	}
-
 	return query
 }
 
···
 		searchPattern := "%" + opts.Search + "%"
 		args = append(args, searchPattern, searchPattern, searchPattern)
 	}
-
 	return args
 }
 
 // scanBookRow scans a database row into a book model
 func scanBookRow(rows *sql.Rows, book *models.Book) error {
 	var pages sql.NullInt64
-
 	if err := rows.Scan(&book.ID, &book.Title, &book.Author, &book.Status, &book.Progress, &pages,
 		&book.Rating, &book.Notes, &book.Added, &book.Started, &book.Finished); err != nil {
 		return err
 	}
-
 	if pages.Valid {
 		book.Pages = int(pages.Int64)
 	}
-
 	return nil
 }
 
 // scanBookRowSingle scans a single database row into a book model
 func scanBookRowSingle(row *sql.Row, book *models.Book) error {
 	var pages sql.NullInt64
-
 	if err := row.Scan(&book.ID, &book.Title, &book.Author, &book.Status, &book.Progress, &pages,
 		&book.Rating, &book.Notes, &book.Added, &book.Started, &book.Finished); err != nil {
 		return err
 	}
-
 	if pages.Valid {
 		book.Pages = int(pages.Int64)
 	}
-
 	return nil
 }
 
···
 	if len(conditions) > 0 {
 		query += " WHERE " + strings.Join(conditions, " AND ")
 	}
-
 	return r.BaseMediaRepository.CountQuery(ctx, query, args...)
 }
 
···
 			book.Started = &now
 		}
 	}
-
 	return r.Update(ctx, book)
 }
 
···
 	Limit       int
 	Offset      int
 }
+
+// Validate validates a book model
+func (r *BookRepository) Validate(model models.Model) error {
+	book, ok := model.(*models.Book)
+	if !ok {
+		return services.NewValidationError("model", "expected Book model")
+	}
+
+	validator := services.NewValidator()
+
+	validator.Check(services.RequiredString("Title", book.Title))
+	validator.Check(services.ValidEnum("Status", book.Status, book.ValidStatuses()))
+	validator.Check(services.StringLength("Title", book.Title, 1, 500))
+	validator.Check(services.StringLength("Author", book.Author, 0, 200))
+	validator.Check(services.StringLength("Notes", book.Notes, 0, 2000))
+
+	if book.Progress < 0 || book.Progress > 100 {
+		validator.Check(services.NewValidationError("Progress", "must be between 0 and 100"))
+	}
+
+	if book.Rating < 0 || book.Rating > 5 {
+		validator.Check(services.NewValidationError("Rating", "must be between 0 and 5"))
+	}
+
+	if book.Pages < 0 {
+		validator.Check(services.NewValidationError("Pages", "must be non-negative"))
+	}
+
+	if book.ID > 0 {
+		validator.Check(services.PositiveID("ID", book.ID))
+	}
+
+	if !book.Added.IsZero() && book.Started != nil && book.Added.After(*book.Started) {
+		validator.Check(services.NewValidationError("Added", "cannot be after Started timestamp"))
+	}
+	return validator.Errors()
+}

internal/services/validation.go

···
 )
 
 var (
-	emailRegex = regexp.MustCompile(`^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$`)
-
+	emailRegex  = regexp.MustCompile(`^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$`)
 	dateFormats = []string{
 		"2006-01-02",
 		"2006-01-02T15:04:05Z",
···
 	return fmt.Sprintf("validation error for field '%s': %s", e.Field, e.Message)
 }
 
+func NewValidationError(f, m string) ValidationError {
+	return ValidationError{Field: f, Message: m}
+}
+
 // ValidationErrors represents multiple validation errors
 type ValidationErrors []ValidationError
 
···
 // RequiredString validates that a string field is not empty
 func RequiredString(name, value string) error {
 	if strings.TrimSpace(value) == "" {
-		return ValidationError{Field: name, Message: "is required and cannot be empty"}
+		return NewValidationError(name, "is required and cannot be empty")
 	}
 	return nil
 }
···
 	}
 
 	if parsed.Scheme != "http" && parsed.Scheme != "https" {
-		return ValidationError{Field: name, Message: "must use http or https scheme"}
+		return NewValidationError(name, "must use http or https scheme")
 	}
 
 	return nil
···
 	}
 
 	if !emailRegex.MatchString(value) {
-		return ValidationError{Field: name, Message: "must be a valid email address"}
+		return NewValidationError(name, "must be a valid email address")
 	}
 
 	return nil
···
 // StringLength validates string length constraints
 func StringLength(name, value string, min, max int) error {
 	length := len(strings.TrimSpace(value))
-
 	if min > 0 && length < min {
-		return ValidationError{Field: name, Message: fmt.Sprintf("must be at least %d characters long", min)}
+		return NewValidationError(name, fmt.Sprintf("must be at least %d characters long", min))
 	}
-
 	if max > 0 && length > max {
-		return ValidationError{Field: name, Message: fmt.Sprintf("must not exceed %d characters", max)}
+		return NewValidationError(name, fmt.Sprintf("must not exceed %d characters", max))
 	}
-
 	return nil
 }
 
···
 			return nil
 		}
 	}
-
-	return ValidationError{
-		Field:   name,
-		Message: "must be a valid date (YYYY-MM-DD, YYYY-MM-DDTHH:MM:SSZ, etc.)",
-	}
+	return NewValidationError(name, "must be a valid date (YYYY-MM-DD, YYYY-MM-DDTHH:MM:SSZ, etc.)")
 }
 
 // PositiveID validates that an ID is positive
 func PositiveID(name string, value int64) error {
 	if value <= 0 {
-		return ValidationError{Field: name, Message: "must be a positive integer"}
+		return NewValidationError(name, "must be a positive integer")
 	}
 	return nil
 }
···
 	if value == "" {
 		return nil
 	}
-
 	if slices.Contains(allowedValues, value) {
 		return nil
 	}
-
-	message := fmt.Sprintf("must be one of: %s", strings.Join(allowedValues, ", "))
-	return ValidationError{Field: name, Message: message}
+	return NewValidationError(name, fmt.Sprintf("must be one of: %s", strings.Join(allowedValues, ", ")))
 }
 
 // ValidFilePath validates that a string looks like a valid file path
···
 	if value == "" {
 		return nil
 	}
-
 	if strings.Contains(value, "..") {
-		return ValidationError{Field: name, Message: "cannot contain '..' path traversal"}
+		return NewValidationError(name, "cannot contain '..' path traversal")
 	}
-
 	if strings.ContainsAny(value, "<>:\"|?*") {
-		return ValidationError{Field: name, Message: "contains invalid characters"}
+		return NewValidationError(name, "contains invalid characters")
 	}
-
 	return nil
 }
 
···
 		if valErr, ok := err.(ValidationError); ok {
 			v.errors = append(v.errors, valErr)
 		} else {
-			v.errors = append(v.errors, ValidationError{Field: "unknown", Message: err.Error()})
+			v.errors = append(v.errors, NewValidationError("unknown", err.Error()))
 		}
 	}
 	return v