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

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