Added a /conditions/current endpoint with computed best-guess values for current conditions

internal/adapters/httpapi/server.go

@@ -3,21 +3,30 @@ package httpapi
 import (
 	"context"
 	"encoding/json"
+	"fmt"
 	"net/http"
+	"strconv"
+	"strings"
 	"time"
 
 	"gitea.maximumdirect.net/ejr/weatherapi/internal/application/alerts"
+	"gitea.maximumdirect.net/ejr/weatherapi/internal/application/conditions"
 	"gitea.maximumdirect.net/ejr/weatherapi/internal/application/forecasts"
 	"gitea.maximumdirect.net/ejr/weatherapi/internal/application/observations"
+	"gitea.maximumdirect.net/ejr/weatherapi/internal/platform/constants"
 	"gitea.maximumdirect.net/ejr/weatherapi/internal/platform/timeparse"
 )
 
 type ObservationService interface {
-	GetCurrent(ctx context.Context) (observations.CurrentResponse, error)
+	GetRecent(ctx context.Context, count int, unitSystem string) (observations.Response, error)
+}
+
+type ConditionsService interface {
+	GetCurrent(ctx context.Context, unitSystem string) (conditions.Response, error)
 }
 
 type ForecastService interface {
-	GetByTimestamp(ctx context.Context, ts time.Time) (forecasts.Response, error)
+	GetByTimestamp(ctx context.Context, ts time.Time, unitSystem string) (forecasts.Response, error)
 }
 
 type AlertService interface {
@@ -25,32 +34,67 @@ type AlertService interface {
 }
 
 type Server struct {
-	obsSvc    ObservationService
-	fcSvc     ForecastService
-	alertsSvc AlertService
+	obsSvc        ObservationService
+	conditionsSvc ConditionsService
+	fcSvc         ForecastService
+	alertsSvc     AlertService
 }
 
-func NewServer(obsSvc ObservationService, fcSvc ForecastService, alertsSvc AlertService) *Server {
-	return &Server{obsSvc: obsSvc, fcSvc: fcSvc, alertsSvc: alertsSvc}
+func NewServer(obsSvc ObservationService, conditionsSvc ConditionsService, fcSvc ForecastService, alertsSvc AlertService) *Server {
+	return &Server{obsSvc: obsSvc, conditionsSvc: conditionsSvc, fcSvc: fcSvc, alertsSvc: alertsSvc}
 }
 
 func (s *Server) Handler() http.Handler {
 	mux := http.NewServeMux()
-	mux.HandleFunc("/observations/current", s.handleObservationsCurrent)
+	mux.HandleFunc("/observations", s.handleObservations)
+	mux.HandleFunc("/conditions/current", s.handleConditionsCurrent)
 	mux.HandleFunc("/forecast", s.handleForecast)
 	mux.HandleFunc("/alerts/current", s.handleAlertsCurrent)
 	return mux
 }
 
-func (s *Server) handleObservationsCurrent(w http.ResponseWriter, r *http.Request) {
+func (s *Server) handleConditionsCurrent(w http.ResponseWriter, r *http.Request) {
 	if r.Method != http.MethodGet {
 		writeError(w, http.StatusMethodNotAllowed, "method_not_allowed", "only GET is supported")
 		return
 	}
 
-	resp, err := s.obsSvc.GetCurrent(r.Context())
+	unitSystem, err := parseUnits(r, constants.UnitSystemUS)
 	if err != nil {
-		writeError(w, http.StatusInternalServerError, "internal_error", "failed to fetch current observations")
+		writeError(w, http.StatusBadRequest, "invalid_request", err.Error())
+		return
+	}
+
+	resp, err := s.conditionsSvc.GetCurrent(r.Context(), unitSystem)
+	if err != nil {
+		writeError(w, http.StatusInternalServerError, "internal_error", "failed to fetch current conditions")
+		return
+	}
+
+	writeJSON(w, http.StatusOK, resp)
+}
+
+func (s *Server) handleObservations(w http.ResponseWriter, r *http.Request) {
+	if r.Method != http.MethodGet {
+		writeError(w, http.StatusMethodNotAllowed, "method_not_allowed", "only GET is supported")
+		return
+	}
+
+	unitSystem, err := parseUnits(r, constants.UnitSystemMetric)
+	if err != nil {
+		writeError(w, http.StatusBadRequest, "invalid_request", err.Error())
+		return
+	}
+
+	count, err := parseCount(r)
+	if err != nil {
+		writeError(w, http.StatusBadRequest, "invalid_request", err.Error())
+		return
+	}
+
+	resp, err := s.obsSvc.GetRecent(r.Context(), count, unitSystem)
+	if err != nil {
+		writeError(w, http.StatusInternalServerError, "internal_error", "failed to fetch observations")
 		return
 	}
 
@@ -63,6 +107,12 @@ func (s *Server) handleForecast(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
+	unitSystem, err := parseUnits(r, constants.UnitSystemUS)
+	if err != nil {
+		writeError(w, http.StatusBadRequest, "invalid_request", err.Error())
+		return
+	}
+
 	raw := r.URL.Query().Get("timestamp")
 	ts, err := timeparse.ParseTimestamp(raw)
 	if err != nil {
@@ -70,7 +120,7 @@ func (s *Server) handleForecast(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	resp, err := s.fcSvc.GetByTimestamp(r.Context(), ts)
+	resp, err := s.fcSvc.GetByTimestamp(r.Context(), ts, unitSystem)
 	if err != nil {
 		writeError(w, http.StatusInternalServerError, "internal_error", "failed to fetch forecast")
 		return
@@ -94,6 +144,35 @@ func (s *Server) handleAlertsCurrent(w http.ResponseWriter, r *http.Request) {
 	writeJSON(w, http.StatusOK, resp)
 }
 
+func parseCount(r *http.Request) (int, error) {
+	raw := strings.TrimSpace(r.URL.Query().Get("count"))
+	if raw == "" {
+		return constants.DefaultObservationCount, nil
+	}
+
+	count, err := strconv.Atoi(raw)
+	if err != nil {
+		return 0, fmt.Errorf("count must be an integer between 1 and %d", constants.MaxObservationCount)
+	}
+	if count < 1 || count > constants.MaxObservationCount {
+		return 0, fmt.Errorf("count must be an integer between 1 and %d", constants.MaxObservationCount)
+	}
+	return count, nil
+}
+
+func parseUnits(r *http.Request, defaultSystem string) (string, error) {
+	raw := strings.ToLower(strings.TrimSpace(r.URL.Query().Get("units")))
+	if raw == "" {
+		return defaultSystem, nil
+	}
+	switch raw {
+	case constants.UnitSystemUS, constants.UnitSystemMetric:
+		return raw, nil
+	default:
+		return "", fmt.Errorf("units must be one of: us, metric")
+	}
+}
+
 type errorResponse struct {
 	Code    string `json:"code"`
 	Message string `json:"message"`

internal/adapters/httpapi/server_test.go

@@ -9,6 +9,7 @@ import (
 	"time"
 
 	"gitea.maximumdirect.net/ejr/weatherapi/internal/application/alerts"
+	"gitea.maximumdirect.net/ejr/weatherapi/internal/application/conditions"
 	"gitea.maximumdirect.net/ejr/weatherapi/internal/application/forecasts"
 	"gitea.maximumdirect.net/ejr/weatherapi/internal/application/observations"
 	"gitea.maximumdirect.net/ejr/weatherapi/internal/application/units"
@@ -17,27 +18,21 @@ import (
 )
 
 type fakeObservationRepo struct {
-	summary       ports.ObservationSummaryMetric
-	conditions    []ports.ObservationConditionMetric
-	precip        []string
-	summaryWin    time.Duration
-	conditionsWin time.Duration
-	precipWin     time.Duration
+	summary       ports.ObservationCurrentConditionsMetric
+	summaryWindow time.Duration
+
+	observations []ports.ObservationRecordMetric
+	recentCount  int
 }
 
-func (f *fakeObservationRepo) GetCurrentSummary(_ context.Context, window time.Duration) (ports.ObservationSummaryMetric, error) {
-	f.summaryWin = window
+func (f *fakeObservationRepo) GetCurrentConditionsSummary(_ context.Context, window time.Duration) (ports.ObservationCurrentConditionsMetric, error) {
+	f.summaryWindow = window
 	return f.summary, nil
 }
 
-func (f *fakeObservationRepo) ListCurrentConditions(_ context.Context, window time.Duration) ([]ports.ObservationConditionMetric, error) {
-	f.conditionsWin = window
-	return f.conditions, nil
-}
-
-func (f *fakeObservationRepo) ListCurrentPrecipitationEvents(_ context.Context, window time.Duration) ([]string, error) {
-	f.precipWin = window
-	return f.precip, nil
+func (f *fakeObservationRepo) ListRecentObservations(_ context.Context, count int) ([]ports.ObservationRecordMetric, error) {
+	f.recentCount = count
+	return f.observations, nil
 }
 
 type fakeForecastRepo struct {
@@ -58,15 +53,349 @@ func (fakeAlertRepo) ListCurrentAlerts(context.Context) ([]ports.AlertRecord, er
 	return nil, nil
 }
 
-func TestForecastInvalidTimestampReturns400(t *testing.T) {
-	fcRepo := &fakeForecastRepo{}
-	obsRepo := &fakeObservationRepo{}
+func newTestUnitRegistry(t *testing.T) *units.Registry {
+	t.Helper()
 
-	server := NewServer(
-		observations.NewService(obsRepo, units.USConverter{}, constants.ObservationWindow),
-		forecasts.NewService(fcRepo, units.USConverter{}, constants.ForecastQueryLimit),
+	reg := units.NewRegistry()
+	if err := reg.Register(units.StaticFactory{UnitSystem: constants.UnitSystemUS, Converter: units.USConverter{}}); err != nil {
+		t.Fatalf("register us converter: %v", err)
+	}
+	if err := reg.Register(units.StaticFactory{UnitSystem: constants.UnitSystemMetric, Converter: units.MetricConverter{}}); err != nil {
+		t.Fatalf("register metric converter: %v", err)
+	}
+	return reg
+}
+
+func newTestHandler(t *testing.T, obsRepo *fakeObservationRepo, fcRepo *fakeForecastRepo) http.Handler {
+	t.Helper()
+
+	reg := newTestUnitRegistry(t)
+	return NewServer(
+		observations.NewService(obsRepo, reg),
+		conditions.NewService(obsRepo, reg, constants.ObservationWindow),
+		forecasts.NewService(fcRepo, reg, constants.ForecastQueryLimit),
 		alerts.NewService(fakeAlertRepo{}),
 	).Handler()
+}
+
+func TestLegacyObservationsCurrentPathRemoved(t *testing.T) {
+	server := newTestHandler(t, &fakeObservationRepo{}, &fakeForecastRepo{})
+
+	w := httptest.NewRecorder()
+	server.ServeHTTP(w, httptest.NewRequest(http.MethodGet, "/observations/current", nil))
+	if w.Code != http.StatusNotFound {
+		t.Fatalf("expected 404 for removed /observations/current, got %d", w.Code)
+	}
+}
+
+func TestConditionsCurrentDefaultsToUSUnits(t *testing.T) {
+	tempC := 20.0
+	appTempC := 15.0
+	dewpointC := 10.0
+	relHumidity := 81.0
+	windKmh := 10.0
+	windDir := 270.0
+	conditionCode := 63
+	isDay := true
+
+	obsRepo := &fakeObservationRepo{
+		summary: ports.ObservationCurrentConditionsMetric{
+			TemperatureC:         &tempC,
+			ApparentTemperatureC: &appTempC,
+			DewpointC:            &dewpointC,
+			RelativeHumidity:     &relHumidity,
+			WindSpeedKmh:         &windKmh,
+			WindDirectionDegrees: &windDir,
+			ConditionCode:        &conditionCode,
+			IsDay:                &isDay,
+		},
+	}
+	server := newTestHandler(t, obsRepo, &fakeForecastRepo{})
+
+	w := httptest.NewRecorder()
+	server.ServeHTTP(w, httptest.NewRequest(http.MethodGet, "/conditions/current", nil))
+	if w.Code != http.StatusOK {
+		t.Fatalf("expected 200, got %d", w.Code)
+	}
+
+	var payload map[string]any
+	if err := json.Unmarshal(w.Body.Bytes(), &payload); err != nil {
+		t.Fatalf("decode response: %v", err)
+	}
+	if got := payload["temperatureF"].(float64); got != 68.0 {
+		t.Fatalf("expected temperatureF=68.0, got %v", got)
+	}
+	if got := payload["apparentTemperatureF"].(float64); got != 59.0 {
+		t.Fatalf("expected apparentTemperatureF=59.0, got %v", got)
+	}
+	if got := payload["dewpointF"].(float64); got != 50.0 {
+		t.Fatalf("expected dewpointF=50.0, got %v", got)
+	}
+	if got := payload["windSpeedMph"].(float64); got != 6.2 {
+		t.Fatalf("expected windSpeedMph=6.2, got %v", got)
+	}
+	if got := payload["relativeHumidityPercent"].(float64); got != 81.0 {
+		t.Fatalf("expected relativeHumidityPercent=81.0, got %v", got)
+	}
+	if got := payload["windDirectionDegrees"].(float64); got != 270.0 {
+		t.Fatalf("expected windDirectionDegrees=270.0, got %v", got)
+	}
+	if got := payload["conditionCode"].(float64); got != 63 {
+		t.Fatalf("expected conditionCode=63, got %v", got)
+	}
+	if got := payload["conditionText"].(string); got != "Rain" {
+		t.Fatalf("expected conditionText=Rain, got %v", got)
+	}
+	if got := payload["isDay"].(bool); !got {
+		t.Fatalf("expected isDay=true, got %v", got)
+	}
+	if _, exists := payload["temperatureC"]; exists {
+		t.Fatalf("did not expect metric key temperatureC in default US response")
+	}
+
+	if obsRepo.summaryWindow != constants.ObservationWindow {
+		t.Fatalf("expected observation window %s, got %s", constants.ObservationWindow, obsRepo.summaryWindow)
+	}
+}
+
+func TestConditionsCurrentSupportsMetricUnits(t *testing.T) {
+	tempC := 20.0
+	windKmh := 10.0
+	conditionCode := 63
+	isDay := false
+	obsRepo := &fakeObservationRepo{
+		summary: ports.ObservationCurrentConditionsMetric{
+			TemperatureC:  &tempC,
+			WindSpeedKmh:  &windKmh,
+			ConditionCode: &conditionCode,
+			IsDay:         &isDay,
+		},
+	}
+	server := newTestHandler(t, obsRepo, &fakeForecastRepo{})
+
+	w := httptest.NewRecorder()
+	server.ServeHTTP(w, httptest.NewRequest(http.MethodGet, "/conditions/current?units=metric", nil))
+	if w.Code != http.StatusOK {
+		t.Fatalf("expected 200, got %d", w.Code)
+	}
+
+	var payload map[string]any
+	if err := json.Unmarshal(w.Body.Bytes(), &payload); err != nil {
+		t.Fatalf("decode response: %v", err)
+	}
+	if got := payload["temperatureC"].(float64); got != 20.0 {
+		t.Fatalf("expected temperatureC=20.0, got %v", got)
+	}
+	if got := payload["windSpeedKmh"].(float64); got != 10.0 {
+		t.Fatalf("expected windSpeedKmh=10.0, got %v", got)
+	}
+	if got := payload["conditionCode"].(float64); got != 63 {
+		t.Fatalf("expected conditionCode=63, got %v", got)
+	}
+	if got := payload["conditionText"].(string); got != "Rain" {
+		t.Fatalf("expected conditionText=Rain, got %v", got)
+	}
+	if got := payload["isDay"].(bool); got {
+		t.Fatalf("expected isDay=false, got %v", got)
+	}
+	if _, exists := payload["temperatureF"]; exists {
+		t.Fatalf("did not expect US key temperatureF in metric response")
+	}
+}
+
+func TestConditionsCurrentOmitsConditionFieldsWhenNoObservations(t *testing.T) {
+	obsRepo := &fakeObservationRepo{
+		summary: ports.ObservationCurrentConditionsMetric{},
+	}
+	server := newTestHandler(t, obsRepo, &fakeForecastRepo{})
+
+	w := httptest.NewRecorder()
+	server.ServeHTTP(w, httptest.NewRequest(http.MethodGet, "/conditions/current", nil))
+	if w.Code != http.StatusOK {
+		t.Fatalf("expected 200, got %d", w.Code)
+	}
+
+	var payload map[string]any
+	if err := json.Unmarshal(w.Body.Bytes(), &payload); err != nil {
+		t.Fatalf("decode response: %v", err)
+	}
+	if _, exists := payload["conditionCode"]; exists {
+		t.Fatalf("expected conditionCode omitted when no observations")
+	}
+	if _, exists := payload["conditionText"]; exists {
+		t.Fatalf("expected conditionText omitted when no observations")
+	}
+	if _, exists := payload["isDay"]; exists {
+		t.Fatalf("expected isDay omitted when no observations")
+	}
+}
+
+func TestConditionsCurrentConditionTextUsesNilDayFallback(t *testing.T) {
+	conditionCode := 0
+	obsRepo := &fakeObservationRepo{
+		summary: ports.ObservationCurrentConditionsMetric{
+			ConditionCode: &conditionCode,
+		},
+	}
+	server := newTestHandler(t, obsRepo, &fakeForecastRepo{})
+
+	w := httptest.NewRecorder()
+	server.ServeHTTP(w, httptest.NewRequest(http.MethodGet, "/conditions/current", nil))
+	if w.Code != http.StatusOK {
+		t.Fatalf("expected 200, got %d", w.Code)
+	}
+
+	var payload map[string]any
+	if err := json.Unmarshal(w.Body.Bytes(), &payload); err != nil {
+		t.Fatalf("decode response: %v", err)
+	}
+	if got := payload["conditionText"].(string); got != "Sunny" {
+		t.Fatalf("expected conditionText=Sunny, got %v", got)
+	}
+	if _, exists := payload["isDay"]; exists {
+		t.Fatalf("expected isDay omitted when summary isDay is nil")
+	}
+}
+
+func TestObservationsDefaultsToMetricAndDefaultCount(t *testing.T) {
+	tempC := 10.0
+	windKmh := 16.0
+	stationID := "KSTL"
+	stationName := "St Louis"
+	textDescription := "Cloudy"
+
+	obsRepo := &fakeObservationRepo{
+		observations: []ports.ObservationRecordMetric{
+			{
+				EventID:         "evt-1",
+				StationID:       &stationID,
+				StationName:     &stationName,
+				Timestamp:       time.Date(2026, 3, 17, 12, 0, 0, 0, time.UTC),
+				ConditionCode:   3,
+				TextDescription: &textDescription,
+				TemperatureC:    &tempC,
+				WindSpeedKmh:    &windKmh,
+				PresentWeather:  []ports.ObservationPresentWeatherMetric{{Raw: map[string]any{"wx": "rain"}}},
+			},
+		},
+	}
+	server := newTestHandler(t, obsRepo, &fakeForecastRepo{})
+
+	w := httptest.NewRecorder()
+	server.ServeHTTP(w, httptest.NewRequest(http.MethodGet, "/observations", nil))
+	if w.Code != http.StatusOK {
+		t.Fatalf("expected 200, got %d", w.Code)
+	}
+
+	if obsRepo.recentCount != constants.DefaultObservationCount {
+		t.Fatalf("expected default count %d, got %d", constants.DefaultObservationCount, obsRepo.recentCount)
+	}
+
+	var payload map[string]any
+	if err := json.Unmarshal(w.Body.Bytes(), &payload); err != nil {
+		t.Fatalf("decode response: %v", err)
+	}
+	observationsList := payload["observations"].([]any)
+	first := observationsList[0].(map[string]any)
+
+	if got := first["temperatureC"].(float64); got != 10.0 {
+		t.Fatalf("expected temperatureC=10.0, got %v", got)
+	}
+	if got := first["windSpeedKmh"].(float64); got != 16.0 {
+		t.Fatalf("expected windSpeedKmh=16.0, got %v", got)
+	}
+	if _, exists := first["temperatureF"]; exists {
+		t.Fatalf("did not expect US key temperatureF in metric response")
+	}
+	if got := first["conditionCode"].(float64); got != 3 {
+		t.Fatalf("expected conditionCode=3, got %v", got)
+	}
+
+	pw := first["presentWeather"].([]any)
+	raw := pw[0].(map[string]any)["raw"].(map[string]any)
+	if got := raw["wx"]; got != "rain" {
+		t.Fatalf("expected presentWeather raw payload preserved, got %v", got)
+	}
+}
+
+func TestObservationsSupportsUSUnitsAndCountOverride(t *testing.T) {
+	tempC := 10.0
+	windKmh := 16.09344
+	obsRepo := &fakeObservationRepo{
+		observations: []ports.ObservationRecordMetric{
+			{
+				EventID:       "evt-1",
+				Timestamp:     time.Date(2026, 3, 17, 12, 0, 0, 0, time.UTC),
+				ConditionCode: 1,
+				TemperatureC:  &tempC,
+				WindSpeedKmh:  &windKmh,
+			},
+		},
+	}
+	server := newTestHandler(t, obsRepo, &fakeForecastRepo{})
+
+	w := httptest.NewRecorder()
+	server.ServeHTTP(w, httptest.NewRequest(http.MethodGet, "/observations?count=2&units=us", nil))
+	if w.Code != http.StatusOK {
+		t.Fatalf("expected 200, got %d", w.Code)
+	}
+	if obsRepo.recentCount != 2 {
+		t.Fatalf("expected count override 2, got %d", obsRepo.recentCount)
+	}
+
+	var payload map[string]any
+	if err := json.Unmarshal(w.Body.Bytes(), &payload); err != nil {
+		t.Fatalf("decode response: %v", err)
+	}
+	first := payload["observations"].([]any)[0].(map[string]any)
+	if got := first["temperatureF"].(float64); got != 50.0 {
+		t.Fatalf("expected temperatureF=50.0, got %v", got)
+	}
+	if got := first["windSpeedMph"].(float64); got != 10.0 {
+		t.Fatalf("expected windSpeedMph=10.0, got %v", got)
+	}
+	if _, exists := first["temperatureC"]; exists {
+		t.Fatalf("did not expect metric key temperatureC in US response")
+	}
+}
+
+func TestObservationsCountValidation(t *testing.T) {
+	server := newTestHandler(t, &fakeObservationRepo{}, &fakeForecastRepo{})
+
+	cases := []string{
+		"/observations?count=0",
+		"/observations?count=-1",
+		"/observations?count=abc",
+		"/observations?count=101",
+	}
+	for _, path := range cases {
+		w := httptest.NewRecorder()
+		server.ServeHTTP(w, httptest.NewRequest(http.MethodGet, path, nil))
+		if w.Code != http.StatusBadRequest {
+			t.Fatalf("expected 400 for %s, got %d", path, w.Code)
+		}
+	}
+}
+
+func TestInvalidUnitsReturn400(t *testing.T) {
+	server := newTestHandler(t, &fakeObservationRepo{}, &fakeForecastRepo{})
+
+	cases := []string{
+		"/conditions/current?units=bad",
+		"/observations?units=bad",
+		"/forecast?timestamp=2026-03-17T12:30:00Z&units=bad",
+	}
+	for _, path := range cases {
+		w := httptest.NewRecorder()
+		server.ServeHTTP(w, httptest.NewRequest(http.MethodGet, path, nil))
+		if w.Code != http.StatusBadRequest {
+			t.Fatalf("expected 400 for %s, got %d", path, w.Code)
+		}
+	}
+}
+
+func TestForecastInvalidTimestampReturns400(t *testing.T) {
+	server := newTestHandler(t, &fakeObservationRepo{}, &fakeForecastRepo{})
 
 	req := httptest.NewRequest(http.MethodGet, "/forecast?timestamp=bad-time", nil)
 	w := httptest.NewRecorder()
@@ -85,85 +414,7 @@ func TestForecastInvalidTimestampReturns400(t *testing.T) {
 	}
 }
 
-func TestObservationsCurrentReturnsUSUnits(t *testing.T) {
-	summaryTemp := 20.0
-	summaryAppTemp := 15.0
-	condTemp := 10.0
-	station := "KSTL"
-	text := "Cloudy"
-	providerText := "OVC"
-	conditionText := "Cloudy"
-
-	obsRepo := &fakeObservationRepo{
-		summary: ports.ObservationSummaryMetric{
-			TemperatureC:         &summaryTemp,
-			ApparentTemperatureC: &summaryAppTemp,
-		},
-		conditions: []ports.ObservationConditionMetric{
-			{
-				StationID:              &station,
-				ObservedAt:             time.Date(2026, 3, 17, 12, 0, 0, 0, time.UTC),
-				TemperatureC:           &condTemp,
-				TextDescription:        &text,
-				ProviderRawDescription: &providerText,
-				ConditionText:          &conditionText,
-			},
-		},
-		precip: []string{"rain"},
-	}
-
-	fcRepo := &fakeForecastRepo{}
-	server := NewServer(
-		observations.NewService(obsRepo, units.USConverter{}, constants.ObservationWindow),
-		forecasts.NewService(fcRepo, units.USConverter{}, constants.ForecastQueryLimit),
-		alerts.NewService(fakeAlertRepo{}),
-	).Handler()
-
-	req := httptest.NewRequest(http.MethodGet, "/observations/current", nil)
-	w := httptest.NewRecorder()
-	server.ServeHTTP(w, req)
-
-	if w.Code != http.StatusOK {
-		t.Fatalf("expected 200, got %d", w.Code)
-	}
-
-	var payload map[string]any
-	if err := json.Unmarshal(w.Body.Bytes(), &payload); err != nil {
-		t.Fatalf("decode response: %v", err)
-	}
-
-	summary := payload["summary"].(map[string]any)
-	if got := summary["temperatureF"].(float64); got != 68.0 {
-		t.Fatalf("expected summary temperatureF=68.0, got %v", got)
-	}
-	if got := summary["apparentTemperatureF"].(float64); got != 59.0 {
-		t.Fatalf("expected summary apparentTemperatureF=59.0, got %v", got)
-	}
-	if _, exists := summary["temperatureC"]; exists {
-		t.Fatalf("did not expect metric key temperatureC in US response")
-	}
-	if _, exists := summary["windowMinutes"]; exists {
-		t.Fatalf("did not expect deprecated key windowMinutes in observations summary")
-	}
-
-	conditions := payload["conditions"].([]any)
-	first := conditions[0].(map[string]any)
-	if got := first["temperatureF"].(float64); got != 50.0 {
-		t.Fatalf("expected conditions[0].temperatureF=50.0, got %v", got)
-	}
-	if _, exists := first["providerRawDescription"]; exists {
-		t.Fatalf("did not expect deprecated key providerRawDescription in observations condition")
-	}
-	if _, exists := first["conditionText"]; exists {
-		t.Fatalf("did not expect deprecated key conditionText in observations condition")
-	}
-
-	if obsRepo.summaryWin != constants.ObservationWindow || obsRepo.conditionsWin != constants.ObservationWindow || obsRepo.precipWin != constants.ObservationWindow {
-		t.Fatalf("expected observation window %s to be used", constants.ObservationWindow)
-	}
-}
-
-func TestForecastReturnsUSUnits(t *testing.T) {
+func TestForecastUnitSelection(t *testing.T) {
 	tempC := 0.0
 	tempMinC := -1.0
 	tempMaxC := 1.0
@@ -189,49 +440,48 @@ func TestForecastReturnsUSUnits(t *testing.T) {
 			},
 		},
 	}
+	server := newTestHandler(t, &fakeObservationRepo{}, fcRepo)
 
-	obsRepo := &fakeObservationRepo{}
-	server := NewServer(
-		observations.NewService(obsRepo, units.USConverter{}, constants.ObservationWindow),
-		forecasts.NewService(fcRepo, units.USConverter{}, constants.ForecastQueryLimit),
-		alerts.NewService(fakeAlertRepo{}),
-	).Handler()
-
-	req := httptest.NewRequest(http.MethodGet, "/forecast?timestamp=2026-03-17T12:30:00Z", nil)
-	w := httptest.NewRecorder()
-	server.ServeHTTP(w, req)
-
-	if w.Code != http.StatusOK {
-		t.Fatalf("expected 200, got %d", w.Code)
+	wUS := httptest.NewRecorder()
+	server.ServeHTTP(wUS, httptest.NewRequest(http.MethodGet, "/forecast?timestamp=2026-03-17T12:30:00Z", nil))
+	if wUS.Code != http.StatusOK {
+		t.Fatalf("expected US forecast 200, got %d", wUS.Code)
 	}
 
-	var payload map[string]any
-	if err := json.Unmarshal(w.Body.Bytes(), &payload); err != nil {
-		t.Fatalf("decode response: %v", err)
+	var usPayload map[string]any
+	if err := json.Unmarshal(wUS.Body.Bytes(), &usPayload); err != nil {
+		t.Fatalf("decode us forecast: %v", err)
 	}
-
-	periods := payload["periods"].([]any)
-	first := periods[0].(map[string]any)
-	if got := first["temperatureF"].(float64); got != 32.0 {
+	usPeriod := usPayload["periods"].([]any)[0].(map[string]any)
+	if got := usPeriod["temperatureF"].(float64); got != 32.0 {
 		t.Fatalf("expected temperatureF=32.0, got %v", got)
 	}
-	if got := first["temperatureFMin"].(float64); got != 30.2 {
-		t.Fatalf("expected temperatureFMin=30.2, got %v", got)
-	}
-	if got := first["temperatureFMax"].(float64); got != 33.8 {
-		t.Fatalf("expected temperatureFMax=33.8, got %v", got)
-	}
-	if got := first["apparentTemperatureF"].(float64); got != 28.4 {
-		t.Fatalf("expected apparentTemperatureF=28.4, got %v", got)
-	}
-	if got := first["windSpeedMph"].(float64); got != 6.2 {
+	if got := usPeriod["windSpeedMph"].(float64); got != 6.2 {
 		t.Fatalf("expected windSpeedMph=6.2, got %v", got)
 	}
-	if got := first["windGustMph"].(float64); got != 10.0 {
-		t.Fatalf("expected windGustMph=10.0, got %v", got)
+	if _, exists := usPeriod["temperatureC"]; exists {
+		t.Fatalf("did not expect metric key temperatureC in US response")
 	}
-	if _, exists := first["windSpeedKmh"]; exists {
-		t.Fatalf("did not expect metric key windSpeedKmh in US response")
+
+	wMetric := httptest.NewRecorder()
+	server.ServeHTTP(wMetric, httptest.NewRequest(http.MethodGet, "/forecast?timestamp=2026-03-17T12:30:00Z&units=metric", nil))
+	if wMetric.Code != http.StatusOK {
+		t.Fatalf("expected metric forecast 200, got %d", wMetric.Code)
+	}
+
+	var metricPayload map[string]any
+	if err := json.Unmarshal(wMetric.Body.Bytes(), &metricPayload); err != nil {
+		t.Fatalf("decode metric forecast: %v", err)
+	}
+	metricPeriod := metricPayload["periods"].([]any)[0].(map[string]any)
+	if got := metricPeriod["temperatureC"].(float64); got != 0.0 {
+		t.Fatalf("expected temperatureC=0.0, got %v", got)
+	}
+	if got := metricPeriod["windSpeedKmh"].(float64); got != 10.0 {
+		t.Fatalf("expected windSpeedKmh=10.0, got %v", got)
+	}
+	if _, exists := metricPeriod["temperatureF"]; exists {
+		t.Fatalf("did not expect US key temperatureF in metric response")
 	}
 
 	if fcRepo.gotLimit != constants.ForecastQueryLimit {
@@ -241,73 +491,3 @@ func TestForecastReturnsUSUnits(t *testing.T) {
 		t.Fatalf("expected forecast timestamp passed to repo")
 	}
 }
-
-func TestNullFieldsAreOmittedFromJSON(t *testing.T) {
-	obsRepo := &fakeObservationRepo{
-		summary: ports.ObservationSummaryMetric{},
-		conditions: []ports.ObservationConditionMetric{
-			{
-				ObservedAt: time.Date(2026, 3, 17, 12, 0, 0, 0, time.UTC),
-			},
-		},
-	}
-	fcRepo := &fakeForecastRepo{
-		periods: []ports.ForecastPeriodMetric{
-			{
-				PeriodIndex:   1,
-				StartTime:     time.Date(2026, 3, 17, 12, 0, 0, 0, time.UTC),
-				EndTime:       time.Date(2026, 3, 17, 13, 0, 0, 0, time.UTC),
-				ConditionCode: 1,
-			},
-		},
-	}
-
-	server := NewServer(
-		observations.NewService(obsRepo, units.USConverter{}, constants.ObservationWindow),
-		forecasts.NewService(fcRepo, units.USConverter{}, constants.ForecastQueryLimit),
-		alerts.NewService(fakeAlertRepo{}),
-	).Handler()
-
-	wObs := httptest.NewRecorder()
-	server.ServeHTTP(wObs, httptest.NewRequest(http.MethodGet, "/observations/current", nil))
-	if wObs.Code != http.StatusOK {
-		t.Fatalf("expected observations 200, got %d", wObs.Code)
-	}
-
-	var obsPayload map[string]any
-	if err := json.Unmarshal(wObs.Body.Bytes(), &obsPayload); err != nil {
-		t.Fatalf("decode observations response: %v", err)
-	}
-	summary := obsPayload["summary"].(map[string]any)
-	if _, exists := summary["temperatureF"]; exists {
-		t.Fatalf("expected summary.temperatureF to be omitted when nil")
-	}
-	if _, exists := summary["windowMinutes"]; exists {
-		t.Fatalf("expected summary.windowMinutes to be omitted")
-	}
-
-	conditions := obsPayload["conditions"].([]any)
-	firstCond := conditions[0].(map[string]any)
-	if _, exists := firstCond["temperatureF"]; exists {
-		t.Fatalf("expected conditions[0].temperatureF to be omitted when nil")
-	}
-
-	wFc := httptest.NewRecorder()
-	server.ServeHTTP(wFc, httptest.NewRequest(http.MethodGet, "/forecast?timestamp=2026-03-17T12:30:00Z", nil))
-	if wFc.Code != http.StatusOK {
-		t.Fatalf("expected forecast 200, got %d", wFc.Code)
-	}
-
-	var fcPayload map[string]any
-	if err := json.Unmarshal(wFc.Body.Bytes(), &fcPayload); err != nil {
-		t.Fatalf("decode forecast response: %v", err)
-	}
-	periods := fcPayload["periods"].([]any)
-	firstPeriod := periods[0].(map[string]any)
-	if _, exists := firstPeriod["temperatureF"]; exists {
-		t.Fatalf("expected periods[0].temperatureF to be omitted when nil")
-	}
-	if _, exists := firstPeriod["windSpeedMph"]; exists {
-		t.Fatalf("expected periods[0].windSpeedMph to be omitted when nil")
-	}
-}

internal/adapters/postgres/observations_repo.go

@@ -3,6 +3,7 @@ package postgres
 import (
 	"context"
 	"database/sql"
+	"encoding/json"
 	"fmt"
 	"time"
 
@@ -18,84 +19,161 @@ func NewObservationRepository(pool *pgxpool.Pool) *ObservationRepository {
 	return &ObservationRepository{pool: pool}
 }
 
-func (r *ObservationRepository) GetCurrentSummary(ctx context.Context, window time.Duration) (ports.ObservationSummaryMetric, error) {
+func (r *ObservationRepository) GetCurrentConditionsSummary(ctx context.Context, window time.Duration) (ports.ObservationCurrentConditionsMetric, error) {
 	var temperature sql.NullFloat64
 	var apparent sql.NullFloat64
+	var dewpoint sql.NullFloat64
+	var relativeHumidity sql.NullFloat64
+	var windSpeed sql.NullFloat64
+	var windDirection sql.NullFloat64
+	var conditionCode sql.NullInt64
+	var isDay sql.NullBool
 
-	if err := r.pool.QueryRow(ctx, queryObservationSummary, windowMinutes(window)).Scan(&temperature, &apparent); err != nil {
-		return ports.ObservationSummaryMetric{}, fmt.Errorf("query observation summary: %w", err)
+	if err := r.pool.QueryRow(ctx, queryCurrentConditionsSummary, windowMinutes(window)).Scan(
+		&temperature,
+		&apparent,
+		&dewpoint,
+		&relativeHumidity,
+		&windSpeed,
+		&windDirection,
+		&conditionCode,
+		&isDay,
+	); err != nil {
+		return ports.ObservationCurrentConditionsMetric{}, fmt.Errorf("query current conditions summary: %w", err)
 	}
 
-	return ports.ObservationSummaryMetric{
+	return ports.ObservationCurrentConditionsMetric{
 		TemperatureC:         ptrFloat64(temperature),
 		ApparentTemperatureC: ptrFloat64(apparent),
+		DewpointC:            ptrFloat64(dewpoint),
+		RelativeHumidity:     ptrFloat64(relativeHumidity),
+		WindSpeedKmh:         ptrFloat64(windSpeed),
+		WindDirectionDegrees: ptrFloat64(windDirection),
+		ConditionCode:        ptrInt(conditionCode),
+		IsDay:                ptrBool(isDay),
 	}, nil
 }
 
-func (r *ObservationRepository) ListCurrentConditions(ctx context.Context, window time.Duration) ([]ports.ObservationConditionMetric, error) {
-	rows, err := r.pool.Query(ctx, queryObservationConditions, windowMinutes(window))
+func (r *ObservationRepository) ListRecentObservations(ctx context.Context, count int) ([]ports.ObservationRecordMetric, error) {
+	rows, err := r.pool.Query(ctx, queryRecentObservations, count)
 	if err != nil {
-		return nil, fmt.Errorf("query observation conditions: %w", err)
+		return nil, fmt.Errorf("query recent observations: %w", err)
 	}
 	defer rows.Close()
 
-	out := make([]ports.ObservationConditionMetric, 0)
+	out := make([]ports.ObservationRecordMetric, 0, count)
+	eventIDs := make([]string, 0, count)
 	for rows.Next() {
+		var eventID string
 		var stationID sql.NullString
-		var observedAt time.Time
-		var temperature sql.NullFloat64
+		var stationName sql.NullString
+		var timestamp time.Time
+		var conditionCode int
+		var isDay sql.NullBool
 		var textDescription sql.NullString
-		var providerRawDescription sql.NullString
-		var conditionText sql.NullString
+		var temperature sql.NullFloat64
+		var dewpoint sql.NullFloat64
+		var windDirection sql.NullFloat64
+		var windSpeed sql.NullFloat64
+		var windGust sql.NullFloat64
+		var pressure sql.NullFloat64
+		var visibility sql.NullFloat64
+		var relativeHumidity sql.NullFloat64
+		var apparent sql.NullFloat64
 
 		if err := rows.Scan(
+			&eventID,
 			&stationID,
-			&observedAt,
-			&temperature,
+			&stationName,
+			&timestamp,
+			&conditionCode,
+			&isDay,
 			&textDescription,
-			&providerRawDescription,
-			&conditionText,
+			&temperature,
+			&dewpoint,
+			&windDirection,
+			&windSpeed,
+			&windGust,
+			&pressure,
+			&visibility,
+			&relativeHumidity,
+			&apparent,
 		); err != nil {
-			return nil, fmt.Errorf("scan observation condition row: %w", err)
+			return nil, fmt.Errorf("scan recent observation row: %w", err)
 		}
 
-		out = append(out, ports.ObservationConditionMetric{
-			StationID:              ptrString(stationID),
-			ObservedAt:             observedAt,
-			TemperatureC:           ptrFloat64(temperature),
-			TextDescription:        ptrString(textDescription),
-			ProviderRawDescription: ptrString(providerRawDescription),
-			ConditionText:          ptrString(conditionText),
+		eventIDs = append(eventIDs, eventID)
+		out = append(out, ports.ObservationRecordMetric{
+			EventID:                 eventID,
+			StationID:               ptrString(stationID),
+			StationName:             ptrString(stationName),
+			Timestamp:               timestamp,
+			ConditionCode:           conditionCode,
+			IsDay:                   ptrBool(isDay),
+			TextDescription:         ptrString(textDescription),
+			TemperatureC:            ptrFloat64(temperature),
+			DewpointC:               ptrFloat64(dewpoint),
+			WindDirectionDegrees:    ptrFloat64(windDirection),
+			WindSpeedKmh:            ptrFloat64(windSpeed),
+			WindGustKmh:             ptrFloat64(windGust),
+			BarometricPressurePa:    ptrFloat64(pressure),
+			VisibilityMeters:        ptrFloat64(visibility),
+			RelativeHumidityPercent: ptrFloat64(relativeHumidity),
+			ApparentTemperatureC:    ptrFloat64(apparent),
 		})
 	}
 
 	if err := rows.Err(); err != nil {
-		return nil, fmt.Errorf("iterate observation conditions rows: %w", err)
+		return nil, fmt.Errorf("iterate recent observations rows: %w", err)
+	}
+
+	if len(out) == 0 {
+		return out, nil
+	}
+
+	presentWeatherByEventID, err := r.listObservationPresentWeather(ctx, eventIDs)
+	if err != nil {
+		return nil, err
+	}
+
+	for i := range out {
+		out[i].PresentWeather = presentWeatherByEventID[out[i].EventID]
 	}
 
 	return out, nil
 }
 
-func (r *ObservationRepository) ListCurrentPrecipitationEvents(ctx context.Context, window time.Duration) ([]string, error) {
-	rows, err := r.pool.Query(ctx, queryObservationPrecipitation, windowMinutes(window))
+func (r *ObservationRepository) listObservationPresentWeather(ctx context.Context, eventIDs []string) (map[string][]ports.ObservationPresentWeatherMetric, error) {
+	rows, err := r.pool.Query(ctx, queryObservationPresentWeather, eventIDs)
 	if err != nil {
-		return nil, fmt.Errorf("query observation precipitation events: %w", err)
+		return nil, fmt.Errorf("query observation present weather: %w", err)
 	}
 	defer rows.Close()
 
-	out := make([]string, 0)
+	out := make(map[string][]ports.ObservationPresentWeatherMetric, len(eventIDs))
 	for rows.Next() {
+		var eventID string
+		var weatherIndex int
 		var rawText sql.NullString
-		if err := rows.Scan(&rawText); err != nil {
-			return nil, fmt.Errorf("scan observation precipitation row: %w", err)
+
+		if err := rows.Scan(&eventID, &weatherIndex, &rawText); err != nil {
+			return nil, fmt.Errorf("scan observation present weather row: %w", err)
 		}
+
+		var raw map[string]any
 		if rawText.Valid {
-			out = append(out, rawText.String)
+			if err := json.Unmarshal([]byte(rawText.String), &raw); err != nil {
+				return nil, fmt.Errorf("decode observation present weather raw payload: %w", err)
+			}
 		}
+
+		out[eventID] = append(out[eventID], ports.ObservationPresentWeatherMetric{
+			Raw: raw,
+		})
 	}
 
 	if err := rows.Err(); err != nil {
-		return nil, fmt.Errorf("iterate observation precipitation rows: %w", err)
+		return nil, fmt.Errorf("iterate observation present weather rows: %w", err)
 	}
 
 	return out, nil

internal/adapters/postgres/queries.go

@@ -1,33 +1,80 @@
 package postgres
 
 const (
-	queryObservationSummary = `
+	queryCurrentConditionsSummary = `
+WITH windowed AS (
+	SELECT
+		temperature_c,
+		apparent_temperature_c,
+		dewpoint_c,
+		relative_humidity_percent,
+		wind_speed_kmh,
+		wind_direction_degrees,
+		condition_code,
+		is_day,
+		observed_at
+	FROM observations
+	WHERE observed_at > CURRENT_TIMESTAMP - make_interval(mins => $1)
+)
 SELECT
 	AVG(temperature_c) AS temperature_c,
-	AVG(apparent_temperature_c) AS apparent_temperature_c
-FROM observations
-WHERE observed_at > CURRENT_TIMESTAMP - make_interval(mins => $1);
+	AVG(apparent_temperature_c) AS apparent_temperature_c,
+	AVG(dewpoint_c) AS dewpoint_c,
+	AVG(relative_humidity_percent) AS relative_humidity_percent,
+	AVG(wind_speed_kmh) AS wind_speed_kmh,
+	CASE
+		WHEN COUNT(wind_direction_degrees) FILTER (WHERE wind_direction_degrees IS NOT NULL) = 0 THEN NULL
+		ELSE MOD(
+			DEGREES(
+				ATAN2(
+					AVG(SIN(RADIANS(wind_direction_degrees))),
+					AVG(COS(RADIANS(wind_direction_degrees)))
+				)
+			) + 360.0,
+			360.0
+		)
+	END AS wind_direction_degrees,
+	MAX(condition_code) AS condition_code,
+	(
+		SELECT is_day
+		FROM windowed
+		ORDER BY observed_at DESC
+		LIMIT 1
+	) AS is_day
+FROM windowed;
 `
 
-	queryObservationConditions = `
+	queryRecentObservations = `
 SELECT
+	event_id,
 	station_id,
+	station_name,
 	observed_at,
-	temperature_c,
+	condition_code,
+	is_day,
 	text_description,
-	provider_raw_description,
-	condition_text
+	temperature_c,
+	dewpoint_c,
+	wind_direction_degrees,
+	wind_speed_kmh,
+	wind_gust_kmh,
+	barometric_pressure_pa,
+	visibility_meters,
+	relative_humidity_percent,
+	apparent_temperature_c
 FROM observations
-WHERE observed_at > CURRENT_TIMESTAMP - make_interval(mins => $1)
-ORDER BY observed_at DESC;
+ORDER BY observed_at DESC
+LIMIT $1;
 `
 
-	queryObservationPrecipitation = `
+	queryObservationPresentWeather = `
 SELECT
+	event_id,
+	weather_index,
 	raw_text
 FROM observation_present_weather
-WHERE observed_at > CURRENT_TIMESTAMP - make_interval(mins => $1)
-ORDER BY observed_at DESC;
+WHERE event_id = ANY($1)
+ORDER BY event_id ASC, weather_index ASC;
 `
 
 	queryForecastPeriodsAt = `

internal/adapters/postgres/queries_test.go

@@ -8,18 +8,31 @@ import (
 )
 
 func TestQueriesUseParametersNotHardcodedValues(t *testing.T) {
-	if !strings.Contains(queryObservationSummary, "make_interval(mins => $1)") {
-		t.Fatalf("observation summary query must use $1 minutes parameter")
+	if !strings.Contains(queryCurrentConditionsSummary, "make_interval(mins => $1)") {
+		t.Fatalf("current conditions summary query must use $1 minutes parameter")
 	}
-	if strings.Contains(queryObservationSummary, "30 minutes") {
-		t.Fatalf("observation summary query should not hardcode 30 minutes")
+	if strings.Contains(queryCurrentConditionsSummary, "30 minutes") {
+		t.Fatalf("current conditions summary query should not hardcode 30 minutes")
+	}
+	if !strings.Contains(queryCurrentConditionsSummary, "ATAN2(") {
+		t.Fatalf("current conditions summary query should compute circular mean for wind direction")
+	}
+	if !strings.Contains(queryCurrentConditionsSummary, "MAX(condition_code)") {
+		t.Fatalf("current conditions summary query should compute max condition code")
+	}
+	if !strings.Contains(queryCurrentConditionsSummary, "ORDER BY observed_at DESC") || !strings.Contains(queryCurrentConditionsSummary, "LIMIT 1") {
+		t.Fatalf("current conditions summary query should select latest is_day")
 	}
 
-	if !strings.Contains(queryObservationConditions, "make_interval(mins => $1)") {
-		t.Fatalf("observation conditions query must use $1 minutes parameter")
+	if !strings.Contains(queryRecentObservations, "LIMIT $1") {
+		t.Fatalf("recent observations query must use parameterized limit")
 	}
-	if !strings.Contains(queryObservationPrecipitation, "make_interval(mins => $1)") {
-		t.Fatalf("observation precipitation query must use $1 minutes parameter")
+	if strings.Contains(queryRecentObservations, "LIMIT 5") {
+		t.Fatalf("recent observations query should not hardcode limit=5")
+	}
+
+	if !strings.Contains(queryObservationPresentWeather, "event_id = ANY($1)") {
+		t.Fatalf("observation present weather query must use parameterized event list")
 	}
 
 	if !strings.Contains(queryForecastPeriodsAt, "LIMIT $2") {

internal/adapters/postgres/scan.go

@@ -29,6 +29,14 @@ func ptrBool(v sql.NullBool) *bool {
 	return &b
 }
 
+func ptrInt(v sql.NullInt64) *int {
+	if !v.Valid {
+		return nil
+	}
+	i := int(v.Int64)
+	return &i
+}
+
 func ptrTime(v sql.NullTime) *time.Time {
 	if !v.Valid {
 		return nil