Initial phase 1 baseline implementation

internal/transport/httpapi/server.go

@@ -7,6 +7,7 @@ import (
 	"net/http"
 	"time"
 
+	"drive.local/drivev2/internal/application"
 	"drive.local/drivev2/internal/config"
 )
 
@@ -16,15 +17,16 @@ type Server struct {
 	httpServer *http.Server
 }
 
-func NewServer(cfg config.Config, version string, logger *slog.Logger, frontend http.Handler) *Server {
+type SystemService interface {
+	Readiness(context.Context) error
+	SetupStatus(context.Context) (application.SetupStatus, error)
+}
+
+func NewServer(cfg config.Config, logger *slog.Logger, system SystemService, frontend http.Handler) *Server {
 	mux := http.NewServeMux()
 	mux.HandleFunc("GET /health/live", jsonResponse(http.StatusOK, map[string]string{"status": "live"}))
-	mux.HandleFunc("GET /health/ready", jsonResponse(http.StatusOK, map[string]string{"status": "ready"}))
-	mux.HandleFunc("GET /api/v1/setup/status", jsonResponse(http.StatusOK, map[string]any{
-		"initialized": false,
-		"phase":       "foundation",
-		"version":     version,
-	}))
+	mux.HandleFunc("GET /health/ready", readinessHandler(logger, system))
+	mux.HandleFunc("GET /api/v1/setup/status", setupStatusHandler(logger, system))
 	mux.Handle("/", frontend)
 
 	return &Server{httpServer: &http.Server{
@@ -35,6 +37,29 @@ func NewServer(cfg config.Config, version string, logger *slog.Logger, frontend
 	}}
 }
 
+func readinessHandler(logger *slog.Logger, system SystemService) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		if err := system.Readiness(r.Context()); err != nil {
+			logger.Error("readiness check failed", "error", err)
+			problemResponse(w, http.StatusServiceUnavailable, "dependency_unavailable", "A required dependency is unavailable")
+			return
+		}
+		writeJSON(w, http.StatusOK, map[string]string{"status": "ready"})
+	}
+}
+
+func setupStatusHandler(logger *slog.Logger, system SystemService) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		status, err := system.SetupStatus(r.Context())
+		if err != nil {
+			logger.Error("setup status failed", "error", err)
+			problemResponse(w, http.StatusServiceUnavailable, "dependency_unavailable", "A required dependency is unavailable")
+			return
+		}
+		writeJSON(w, http.StatusOK, status)
+	}
+}
+
 func (s *Server) ListenAndServe() error {
 	return s.httpServer.ListenAndServe()
 }
@@ -44,13 +69,30 @@ func (s *Server) Shutdown(ctx context.Context) error {
 }
 
 func jsonResponse(status int, payload any) http.HandlerFunc {
-	return func(w http.ResponseWriter, _ *http.Request) {
-		w.Header().Set("Content-Type", "application/json")
-		w.Header().Set("Cache-Control", "no-store")
-		w.WriteHeader(status)
-		if err := json.NewEncoder(w).Encode(payload); err != nil {
-			slog.Error("encode response", "error", err)
-		}
+	return func(w http.ResponseWriter, _ *http.Request) { writeJSON(w, status, payload) }
+}
+
+func writeJSON(w http.ResponseWriter, status int, payload any) {
+	w.Header().Set("Content-Type", "application/json")
+	w.Header().Set("Cache-Control", "no-store")
+	w.WriteHeader(status)
+	if err := json.NewEncoder(w).Encode(payload); err != nil {
+		slog.Error("encode response", "error", err)
+	}
+}
+
+func problemResponse(w http.ResponseWriter, status int, code, detail string) {
+	w.Header().Set("Content-Type", "application/problem+json")
+	w.Header().Set("Cache-Control", "no-store")
+	w.WriteHeader(status)
+	if err := json.NewEncoder(w).Encode(map[string]any{
+		"type":   "about:blank",
+		"title":  http.StatusText(status),
+		"status": status,
+		"detail": detail,
+		"code":   code,
+	}); err != nil {
+		slog.Error("encode problem response", "error", err)
 	}
 }