Add local navigation API

internal/query/datasets.go

@@ -0,0 +1,57 @@
+package query
+
+import "github.com/AmanTahiliani/box-box/internal/store"
+
+func emptyDatasetMap() map[string]DatasetInfo {
+	return map[string]DatasetInfo{
+		"meeting":       missingDataset(),
+		"session":       missingDataset(),
+		"drivers":       missingDataset(),
+		"results":       missingDataset(),
+		"starting_grid": missingDataset(),
+		"stints":        missingDataset(),
+		"pit_stops":     missingDataset(),
+		"positions":     missingDataset(),
+		"race_control":  missingDataset(),
+		"weather":       missingDataset(),
+		"laps":          missingDataset(),
+	}
+}
+
+func datasetsFromCounts(meetingAvailable, sessionAvailable bool, counts store.SessionDatasetCounts) map[string]DatasetInfo {
+	ds := emptyDatasetMap()
+	if meetingAvailable {
+		ds["meeting"] = availableLocal(1)
+	}
+	if sessionAvailable {
+		ds["session"] = availableLocal(1)
+	}
+	if counts.Drivers > 0 {
+		ds["drivers"] = availableLocal(counts.Drivers)
+	}
+	if counts.Results > 0 {
+		ds["results"] = availableLocal(counts.Results)
+	}
+	if counts.StartingGrid > 0 {
+		ds["starting_grid"] = availableLocal(counts.StartingGrid)
+	}
+	if counts.Stints > 0 {
+		ds["stints"] = availableLocal(counts.Stints)
+	}
+	if counts.PitStops > 0 {
+		ds["pit_stops"] = availableLocal(counts.PitStops)
+	}
+	if counts.Positions > 0 {
+		ds["positions"] = availableLocal(counts.Positions)
+	}
+	if counts.RaceControl > 0 {
+		ds["race_control"] = availableLocal(counts.RaceControl)
+	}
+	if counts.Weather > 0 {
+		ds["weather"] = availableLocal(counts.Weather)
+	}
+	if counts.Laps > 0 {
+		ds["laps"] = availableLocal(counts.Laps)
+	}
+	return ds
+}

internal/query/navigation.go

@@ -0,0 +1,133 @@
+package query
+
+import (
+	"database/sql"
+	"errors"
+
+	"github.com/AmanTahiliani/box-box/internal/models"
+)
+
+// ErrMeetingNotFound is returned when a meeting is not in the local store.
+var ErrMeetingNotFound = errors.New("meeting not found")
+
+// WeekendSession is one session within a meeting with dataset coverage.
+type WeekendSession struct {
+	Session  models.Session         `json:"session"`
+	Source   string                 `json:"source"`
+	Datasets map[string]DatasetInfo `json:"datasets"`
+}
+
+// Weekend is the local-first read model for one race weekend.
+type Weekend struct {
+	Source            string           `json:"source"`
+	MeetingKey        int              `json:"meeting_key"`
+	Meeting           models.Meeting   `json:"meeting"`
+	Sessions          []WeekendSession `json:"sessions"`
+	DefaultSessionKey int              `json:"default_session_key,omitempty"`
+}
+
+// ListSeasons returns years with ingested meetings, newest first.
+func (s *Service) ListSeasons() ([]int, error) {
+	return s.store.ListYears()
+}
+
+// GetWeekend loads meeting metadata, sessions, and per-session dataset coverage.
+func (s *Service) GetWeekend(meetingKey int) (Weekend, error) {
+	meeting, err := s.store.GetMeeting(meetingKey)
+	if err != nil {
+		if errors.Is(err, sql.ErrNoRows) {
+			return Weekend{}, ErrMeetingNotFound
+		}
+		return Weekend{}, err
+	}
+
+	sessions, err := s.store.ListSessionsByMeeting(meetingKey)
+	if err != nil {
+		return Weekend{}, err
+	}
+
+	out := Weekend{
+		Source:     ResponseSourceNone,
+		MeetingKey: meetingKey,
+		Meeting:    meetingToModel(meeting),
+		Sessions:   []WeekendSession{},
+	}
+
+	if len(sessions) == 0 {
+		return out, nil
+	}
+
+	out.Sessions = make([]WeekendSession, 0, len(sessions))
+	for _, sess := range sessions {
+		counts, err := s.store.CountSessionDatasets(sess.SessionKey)
+		if err != nil {
+			return Weekend{}, err
+		}
+		datasets := datasetsFromCounts(true, true, counts)
+		out.Sessions = append(out.Sessions, WeekendSession{
+			Session:  sessionToModel(sess),
+			Source:   responseSource(datasets),
+			Datasets: datasets,
+		})
+	}
+
+	out.Source = weekendSource(out.Sessions)
+	out.DefaultSessionKey = pickDefaultSession(out.Sessions)
+	return out, nil
+}
+
+func weekendSource(sessions []WeekendSession) string {
+	if len(sessions) == 0 {
+		return ResponseSourceNone
+	}
+	hasLocal := false
+	allMissing := true
+	for _, sess := range sessions {
+		if sess.Source == ResponseSourceNone {
+			continue
+		}
+		allMissing = false
+		if sess.Source == ResponseSourceLocal || sess.Source == ResponseSourcePartial {
+			hasLocal = true
+		}
+	}
+	if allMissing {
+		return ResponseSourceNone
+	}
+	for _, sess := range sessions {
+		if sess.Source == ResponseSourcePartial || sess.Source == ResponseSourceNone {
+			return ResponseSourcePartial
+		}
+	}
+	if hasLocal {
+		return ResponseSourceLocal
+	}
+	return ResponseSourceNone
+}
+
+func pickDefaultSession(sessions []WeekendSession) int {
+	if len(sessions) == 0 {
+		return 0
+	}
+
+	bestIdx := 0
+	bestScore := datasetScore(sessions[0].Datasets)
+	for i := 1; i < len(sessions); i++ {
+		score := datasetScore(sessions[i].Datasets)
+		if score >= bestScore {
+			bestScore = score
+			bestIdx = i
+		}
+	}
+	return sessions[bestIdx].Session.SessionKey
+}
+
+func datasetScore(datasets map[string]DatasetInfo) int {
+	score := 0
+	for _, info := range datasets {
+		if info.Status == DatasetStatusAvailable {
+			score++
+		}
+	}
+	return score
+}

internal/query/query_test.go

@@ -2,6 +2,7 @@ package query
 
 import (
 	"database/sql"
+	"errors"
 	"path/filepath"
 	"testing"
 
@@ -238,3 +239,77 @@ func TestListDriversRequiresSession(t *testing.T) {
 		t.Fatalf("ListDrivers() error = %v, want sql.ErrNoRows", err)
 	}
 }
+
+func TestListSeasonsEmpty(t *testing.T) {
+	svc := openTestService(t)
+
+	years, err := svc.ListSeasons()
+	if err != nil {
+		t.Fatalf("ListSeasons() error = %v", err)
+	}
+	if len(years) != 0 {
+		t.Fatalf("ListSeasons() = %v, want empty", years)
+	}
+}
+
+func TestListSeasonsWithData(t *testing.T) {
+	svc := openTestService(t)
+	seedRaceHubData(t, svc.store)
+
+	years, err := svc.ListSeasons()
+	if err != nil {
+		t.Fatalf("ListSeasons() error = %v", err)
+	}
+	if len(years) != 1 || years[0] != 2025 {
+		t.Fatalf("ListSeasons() = %v, want [2025]", years)
+	}
+}
+
+func TestGetWeekendMissingMeeting(t *testing.T) {
+	svc := openTestService(t)
+
+	_, err := svc.GetWeekend(1229)
+	if err == nil {
+		t.Fatal("GetWeekend() error = nil, want ErrMeetingNotFound")
+	}
+	if !errors.Is(err, ErrMeetingNotFound) {
+		t.Fatalf("GetWeekend() error = %v, want ErrMeetingNotFound", err)
+	}
+}
+
+func TestGetWeekendWithSessions(t *testing.T) {
+	svc := openTestService(t)
+	seedRaceHubData(t, svc.store)
+
+	if err := svc.store.UpsertSession(store.Session{
+		SessionKey:  9000,
+		MeetingKey:  1229,
+		SessionName: "Core Only",
+		SessionType: "Race",
+		DateStart:   "2025-05-24T13:00:00+00:00",
+	}); err != nil {
+		t.Fatalf("UpsertSession() error = %v", err)
+	}
+	if err := svc.store.UpsertSessionDriver(store.SessionDriver{
+		SessionKey: 9000, DriverNumber: 1, MeetingKey: 1229,
+	}); err != nil {
+		t.Fatalf("UpsertSessionDriver() error = %v", err)
+	}
+
+	weekend, err := svc.GetWeekend(1229)
+	if err != nil {
+		t.Fatalf("GetWeekend() error = %v", err)
+	}
+	if weekend.Meeting.MeetingName != "Monaco" {
+		t.Fatalf("MeetingName = %q, want Monaco", weekend.Meeting.MeetingName)
+	}
+	if len(weekend.Sessions) != 2 {
+		t.Fatalf("Sessions len = %d, want 2", len(weekend.Sessions))
+	}
+	if weekend.DefaultSessionKey != 9472 {
+		t.Fatalf("DefaultSessionKey = %d, want 9472 (full data session)", weekend.DefaultSessionKey)
+	}
+	if weekend.Sessions[0].Datasets["drivers"].Status != DatasetStatusAvailable {
+		t.Fatalf("first session drivers = %+v, want available", weekend.Sessions[0].Datasets["drivers"])
+	}
+}

internal/store/counts.go

@@ -0,0 +1,50 @@
+package store
+
+import "database/sql"
+
+// SessionDatasetCounts holds row counts for session-scoped datasets.
+type SessionDatasetCounts struct {
+	Drivers      int
+	Results      int
+	StartingGrid int
+	Stints       int
+	PitStops     int
+	Positions    int
+	RaceControl  int
+	Weather      int
+	Laps         int
+}
+
+// CountSessionDatasets returns row counts for ingested session datasets.
+func (s *Store) CountSessionDatasets(sessionKey int) (SessionDatasetCounts, error) {
+	var c SessionDatasetCounts
+	err := s.db.QueryRow(`
+		SELECT
+			(SELECT COUNT(*) FROM session_drivers WHERE session_key = ?),
+			(SELECT COUNT(*) FROM session_results WHERE session_key = ?),
+			(SELECT COUNT(*) FROM starting_grid WHERE session_key = ?),
+			(SELECT COUNT(*) FROM stints WHERE session_key = ?),
+			(SELECT COUNT(*) FROM pit_stops WHERE session_key = ?),
+			(SELECT COUNT(*) FROM positions WHERE session_key = ?),
+			(SELECT COUNT(*) FROM race_control WHERE session_key = ?),
+			(SELECT COUNT(*) FROM weather WHERE session_key = ?),
+			(SELECT COUNT(*) FROM laps WHERE session_key = ?)
+	`,
+		sessionKey, sessionKey, sessionKey, sessionKey, sessionKey,
+		sessionKey, sessionKey, sessionKey, sessionKey,
+	).Scan(
+		&c.Drivers,
+		&c.Results,
+		&c.StartingGrid,
+		&c.Stints,
+		&c.PitStops,
+		&c.Positions,
+		&c.RaceControl,
+		&c.Weather,
+		&c.Laps,
+	)
+	if err == sql.ErrNoRows {
+		return SessionDatasetCounts{}, nil
+	}
+	return c, err
+}

internal/store/meetings.go

@@ -100,6 +100,30 @@ func (s *Store) GetMeeting(meetingKey int) (Meeting, error) {
 	return m, nil
 }
 
+// ListYears returns distinct meeting years ordered newest first.
+func (s *Store) ListYears() ([]int, error) {
+	rows, err := s.db.Query(`
+		SELECT DISTINCT year
+		FROM meetings
+		WHERE year > 0
+		ORDER BY year DESC
+	`)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+
+	var years []int
+	for rows.Next() {
+		var year int
+		if err := rows.Scan(&year); err != nil {
+			return nil, err
+		}
+		years = append(years, year)
+	}
+	return years, rows.Err()
+}
+
 // ListMeetingsByYear returns meetings for a season ordered by start date.
 func (s *Store) ListMeetingsByYear(year int) ([]Meeting, error) {
 	rows, err := s.db.Query(`

internal/store/store_test.go

@@ -319,6 +319,25 @@ func TestMeetingSessionDriverUpsertsAreIdempotent(t *testing.T) {
 		t.Fatalf("ListSessionsByMeeting() len = %d, want 1", len(sessions))
 	}
 
+	years, err := s.ListYears()
+	if err != nil {
+		t.Fatalf("ListYears() error = %v", err)
+	}
+	if len(years) != 1 || years[0] != 2025 {
+		t.Fatalf("ListYears() = %v, want [2025]", years)
+	}
+
+	counts, err := s.CountSessionDatasets(session.SessionKey)
+	if err != nil {
+		t.Fatalf("CountSessionDatasets() error = %v", err)
+	}
+	if counts.Drivers != 1 {
+		t.Fatalf("CountSessionDatasets().Drivers = %d, want 1", counts.Drivers)
+	}
+	if counts.Results != 0 {
+		t.Fatalf("CountSessionDatasets().Results = %d, want 0", counts.Results)
+	}
+
 	sessionDrivers, err := s.ListSessionDrivers(session.SessionKey)
 	if err != nil {
 		t.Fatalf("ListSessionDrivers() error = %v", err)

internal/web/navigation.go

@@ -0,0 +1,50 @@
+package web
+
+import (
+	"errors"
+	"net/http"
+	"strconv"
+
+	"github.com/AmanTahiliani/box-box/internal/query"
+)
+
+func (s *Server) handleSeasons(w http.ResponseWriter, r *http.Request) {
+	if !s.hasLocalQuery() {
+		writeJSON(w, []int{})
+		return
+	}
+
+	years, err := s.query.ListSeasons()
+	if err != nil {
+		writeError(w, err, http.StatusInternalServerError, false)
+		return
+	}
+	if years == nil {
+		years = []int{}
+	}
+	writeJSON(w, years)
+}
+
+func (s *Server) handleWeekend(w http.ResponseWriter, r *http.Request) {
+	meetingKey, err := strconv.Atoi(r.URL.Query().Get("meeting_key"))
+	if err != nil || meetingKey == 0 {
+		http.Error(w, "meeting_key required", http.StatusBadRequest)
+		return
+	}
+
+	if !s.hasLocalQuery() {
+		writeError(w, query.ErrMeetingNotFound, http.StatusNotFound, false)
+		return
+	}
+
+	weekend, err := s.query.GetWeekend(meetingKey)
+	if err != nil {
+		if errors.Is(err, query.ErrMeetingNotFound) {
+			writeError(w, err, http.StatusNotFound, false)
+			return
+		}
+		writeError(w, err, http.StatusInternalServerError, false)
+		return
+	}
+	writeJSON(w, weekend)
+}

internal/web/racehub_test.go

@@ -150,3 +150,96 @@ func TestHandleRaceHubRequiresSessionKey(t *testing.T) {
 		t.Fatalf("status = %d, want 400", rec.Code)
 	}
 }
+
+func TestHandleSeasonsEmpty(t *testing.T) {
+	srv := testServer(t, nil)
+	req := httptest.NewRequest(http.MethodGet, "/api/v1/seasons", nil)
+	rec := httptest.NewRecorder()
+
+	srv.handleSeasons(rec, req)
+	if rec.Code != http.StatusOK {
+		t.Fatalf("status = %d, want 200", rec.Code)
+	}
+
+	var years []int
+	if err := json.Unmarshal(rec.Body.Bytes(), &years); err != nil {
+		t.Fatalf("decode response: %v", err)
+	}
+	if len(years) != 0 {
+		t.Fatalf("years = %v, want empty", years)
+	}
+}
+
+func TestHandleSeasonsWithData(t *testing.T) {
+	st := openTestStore(t)
+	seedRaceHubStore(t, st)
+	srv := testServer(t, st)
+
+	req := httptest.NewRequest(http.MethodGet, "/api/v1/seasons", nil)
+	rec := httptest.NewRecorder()
+	srv.handleSeasons(rec, req)
+
+	if rec.Code != http.StatusOK {
+		t.Fatalf("status = %d, want 200", rec.Code)
+	}
+
+	var years []int
+	if err := json.Unmarshal(rec.Body.Bytes(), &years); err != nil {
+		t.Fatalf("decode response: %v", err)
+	}
+	if len(years) != 1 || years[0] != 2025 {
+		t.Fatalf("years = %v, want [2025]", years)
+	}
+}
+
+func TestHandleWeekendNotFound(t *testing.T) {
+	st := openTestStore(t)
+	srv := testServer(t, st)
+
+	req := httptest.NewRequest(http.MethodGet, "/api/v1/weekend?meeting_key=1229", nil)
+	rec := httptest.NewRecorder()
+	srv.handleWeekend(rec, req)
+
+	if rec.Code != http.StatusNotFound {
+		t.Fatalf("status = %d, want 404", rec.Code)
+	}
+}
+
+func TestHandleWeekendWithData(t *testing.T) {
+	st := openTestStore(t)
+	seedRaceHubStore(t, st)
+	srv := testServer(t, st)
+
+	req := httptest.NewRequest(http.MethodGet, "/api/v1/weekend?meeting_key=1229", nil)
+	rec := httptest.NewRecorder()
+	srv.handleWeekend(rec, req)
+
+	if rec.Code != http.StatusOK {
+		t.Fatalf("status = %d, want 200", rec.Code)
+	}
+
+	var weekend query.Weekend
+	if err := json.Unmarshal(rec.Body.Bytes(), &weekend); err != nil {
+		t.Fatalf("decode response: %v", err)
+	}
+	if weekend.Meeting.MeetingName != "Monaco" {
+		t.Fatalf("meeting = %q, want Monaco", weekend.Meeting.MeetingName)
+	}
+	if len(weekend.Sessions) != 1 {
+		t.Fatalf("sessions len = %d, want 1", len(weekend.Sessions))
+	}
+	if weekend.DefaultSessionKey != 9472 {
+		t.Fatalf("default_session_key = %d, want 9472", weekend.DefaultSessionKey)
+	}
+}
+
+func TestHandleWeekendRequiresMeetingKey(t *testing.T) {
+	srv := testServer(t, nil)
+	req := httptest.NewRequest(http.MethodGet, "/api/v1/weekend", nil)
+	rec := httptest.NewRecorder()
+
+	srv.handleWeekend(rec, req)
+	if rec.Code != http.StatusBadRequest {
+		t.Fatalf("status = %d, want 400", rec.Code)
+	}
+}

internal/web/server.go

@@ -46,6 +46,8 @@ func (s *Server) Start() error {
 	// REST API — /api/v1/laps/comparison must be registered before /api/v1/laps
 	// because Go's ServeMux uses longest-prefix matching.
 	mux.HandleFunc("/api/v1/race-hub", s.handleRaceHub)
+	mux.HandleFunc("/api/v1/seasons", s.handleSeasons)
+	mux.HandleFunc("/api/v1/weekend", s.handleWeekend)
 	mux.HandleFunc("/api/v1/meetings", s.handleMeetings)
 	mux.HandleFunc("/api/v1/sessions", s.handleSessions)
 	mux.HandleFunc("/api/v1/drivers", s.handleDrivers)