Add channel registry, API & health endpoints

Introduce a new channel package with Channel, RetryConfig and a thread-safe in-memory Registry plus a YAML loader to populate channels at startup. Expand the REST Server to expose channel CRUD endpoints and add /healthz and /readyz probes (readyz uses store Ping when available). Implement Ping on Postgres and SQLite stores to support readiness checks. Add comprehensive tests for the channel registry, YAML loader, REST channel API, and health/readiness behavior. Also add gopkg.in/yaml.v3 dependency.

Author: vagnercazarotto

go.mod

@@ -18,6 +18,7 @@ require (
 	golang.org/x/sync v0.20.0 // indirect
 	golang.org/x/sys v0.42.0 // indirect
 	golang.org/x/tools v0.42.0 // indirect
+	gopkg.in/yaml.v3 v3.0.1 // indirect
 	modernc.org/fileutil v1.4.0 // indirect
 	modernc.org/libc v1.61.13 // indirect
 	modernc.org/mathutil v1.7.1 // indirect

go.sum

@@ -23,6 +23,9 @@ golang.org/x/sys v0.42.0 h1:omrd2nAlyT5ESRdCLYdm3+fMfNFE/+Rf4bDIQImRJeo=
 golang.org/x/sys v0.42.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw=
 golang.org/x/tools v0.42.0 h1:uNgphsn75Tdz5Ji2q36v/nsFSfR/9BRFvqhGBaJGd5k=
 golang.org/x/tools v0.42.0/go.mod h1:Ma6lCIwGZvHK6XtgbswSoWroEkhugApmsXyrUmBhfr0=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
+gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 modernc.org/cc/v4 v4.24.4 h1:TFkx1s6dCkQpd6dKurBNmpo+G8Zl4Sq/ztJ+2+DEsh0=
 modernc.org/cc/v4 v4.24.4/go.mod h1:uVtb5OGqUKpoLWhqwNQo/8LwvoiEBLvZXIQ/SmO6mL0=
 modernc.org/ccgo/v4 v4.23.16 h1:Z2N+kk38b7SfySC1ZkpGLN2vthNJP1+ZzGZIlH7uBxo=

internal/api/rest/server.go

@@ -4,20 +4,29 @@
 //
 //	GET /api/v1/messages          — list messages (query: status, limit)
 //	GET /api/v1/messages/{id}     — get a single message by ID
+//	GET /api/v1/channels          — list channels
+//	POST /api/v1/channels         — create channel
+//	GET /api/v1/channels/{id}     — get channel by ID
+//	PUT /api/v1/channels/{id}     — update channel
+//	DELETE /api/v1/channels/{id}  — delete channel
+//	GET /healthz                  — liveness probe
+//	GET /readyz                   — readiness probe (checks store)
 //
 // All responses are JSON. Error bodies have the shape {"error":"reason"}.
 // The server uses Go 1.22 enhanced ServeMux patterns, so unknown methods
 // receive an automatic 405 and missing routes receive 404.
 package rest
 
 import (
+	"context"
 	"database/sql"
 	"encoding/json"
 	"errors"
 	"net/http"
 	"strconv"
 	"time"
 
+	"github.com/vagnercazarotto/verifhir-gateway/internal/channel"
 	"github.com/vagnercazarotto/verifhir-gateway/internal/store"
 )
 
@@ -43,18 +52,30 @@ type MessageResponse struct {
 	UpdatedAt    time.Time `json:"updated_at"`
 }
 
-// Server is an http.Handler that exposes the message store as a REST API.
+// Server is an http.Handler that exposes the message store and channel
+// registry as a REST API.
 type Server struct {
-	store store.Store
-	mux   *http.ServeMux
+	store    store.Store
+	channels *channel.Registry
+	mux      *http.ServeMux
 }
 
-// New creates a Server backed by st and registers all routes.
-func New(st store.Store) *Server {
-	s := &Server{store: st}
+// New creates a Server backed by st and reg, and registers all routes.
+func New(st store.Store, reg *channel.Registry) *Server {
+	s := &Server{store: st, channels: reg}
 	s.mux = http.NewServeMux()
+	// message routes
 	s.mux.HandleFunc("GET /api/v1/messages", s.listMessages)
 	s.mux.HandleFunc("GET /api/v1/messages/{id}", s.getMessage)
+	// channel routes
+	s.mux.HandleFunc("GET /api/v1/channels", s.listChannels)
+	s.mux.HandleFunc("POST /api/v1/channels", s.createChannel)
+	s.mux.HandleFunc("GET /api/v1/channels/{id}", s.getChannel)
+	s.mux.HandleFunc("PUT /api/v1/channels/{id}", s.updateChannel)
+	s.mux.HandleFunc("DELETE /api/v1/channels/{id}", s.deleteChannel)
+	// health routes
+	s.mux.HandleFunc("GET /healthz", s.healthz)
+	s.mux.HandleFunc("GET /readyz", s.readyz)
 	return s
 }
 
@@ -137,6 +158,94 @@ func recordToResponse(rec *store.Record) MessageResponse {
 	}
 }
 
+// ---- channel handlers -----------------------------------------------------
+
+// listChannels handles GET /api/v1/channels
+func (s *Server) listChannels(w http.ResponseWriter, r *http.Request) {
+	writeJSON(w, http.StatusOK, s.channels.List())
+}
+
+// createChannel handles POST /api/v1/channels
+func (s *Server) createChannel(w http.ResponseWriter, r *http.Request) {
+	var ch channel.Channel
+	if err := json.NewDecoder(r.Body).Decode(&ch); err != nil {
+		writeError(w, http.StatusBadRequest, "invalid JSON body")
+		return
+	}
+	if ch.ID == "" {
+		writeError(w, http.StatusBadRequest, "id is required")
+		return
+	}
+	if ch.URL == "" {
+		writeError(w, http.StatusBadRequest, "url is required")
+		return
+	}
+	if err := s.channels.Add(ch); err != nil {
+		if errors.Is(err, channel.ErrDuplicateID) {
+			writeError(w, http.StatusConflict, "channel ID already exists")
+			return
+		}
+		writeError(w, http.StatusInternalServerError, "failed to create channel")
+		return
+	}
+	got, _ := s.channels.Get(ch.ID)
+	writeJSON(w, http.StatusCreated, got)
+}
+
+// getChannel handles GET /api/v1/channels/{id}
+func (s *Server) getChannel(w http.ResponseWriter, r *http.Request) {
+	id := r.PathValue("id")
+	ch, err := s.channels.Get(id)
+	if err != nil {
+		if errors.Is(err, channel.ErrNotFound) {
+			writeError(w, http.StatusNotFound, "channel not found")
+			return
+		}
+		writeError(w, http.StatusInternalServerError, "failed to retrieve channel")
+		return
+	}
+	writeJSON(w, http.StatusOK, ch)
+}
+
+// updateChannel handles PUT /api/v1/channels/{id}
+func (s *Server) updateChannel(w http.ResponseWriter, r *http.Request) {
+	id := r.PathValue("id")
+	var ch channel.Channel
+	if err := json.NewDecoder(r.Body).Decode(&ch); err != nil {
+		writeError(w, http.StatusBadRequest, "invalid JSON body")
+		return
+	}
+	ch.ID = id // path wins over body
+	if ch.URL == "" {
+		writeError(w, http.StatusBadRequest, "url is required")
+		return
+	}
+	if err := s.channels.Update(ch); err != nil {
+		if errors.Is(err, channel.ErrNotFound) {
+			writeError(w, http.StatusNotFound, "channel not found")
+			return
+		}
+		writeError(w, http.StatusInternalServerError, "failed to update channel")
+		return
+	}
+	got, _ := s.channels.Get(id)
+	writeJSON(w, http.StatusOK, got)
+}
+
+// deleteChannel handles DELETE /api/v1/channels/{id}
+func (s *Server) deleteChannel(w http.ResponseWriter, r *http.Request) {
+	id := r.PathValue("id")
+	if err := s.channels.Delete(id); err != nil {
+		if errors.Is(err, channel.ErrNotFound) {
+			writeError(w, http.StatusNotFound, "channel not found")
+			return
+		}
+		writeError(w, http.StatusInternalServerError, "failed to delete channel")
+		return
+	}
+	w.WriteHeader(http.StatusNoContent)
+}
+
 func writeJSON(w http.ResponseWriter, status int, v any) {
 	w.Header().Set("Content-Type", "application/json")
 	w.WriteHeader(status)
@@ -146,3 +255,32 @@ func writeJSON(w http.ResponseWriter, status int, v any) {
 func writeError(w http.ResponseWriter, status int, msg string) {
 	writeJSON(w, status, map[string]string{"error": msg})
 }
+
+// pinger is an optional interface that store backends may implement.
+// If the backing store satisfies pinger, readyz will call Ping to verify
+// database connectivity.
+type pinger interface {
+	Ping(ctx context.Context) error
+}
+
+// healthz handles GET /healthz — liveness probe.
+// Always returns 200 {"status":"ok"} while the process is running.
+func (s *Server) healthz(w http.ResponseWriter, _ *http.Request) {
+	writeJSON(w, http.StatusOK, map[string]string{"status": "ok"})
+}
+
+// readyz handles GET /readyz — readiness probe.
+// Returns 200 {"status":"ok"} when the store is reachable,
+// or 503 {"status":"unavailable","reason":"..."} otherwise.
+func (s *Server) readyz(w http.ResponseWriter, r *http.Request) {
+	if p, ok := s.store.(pinger); ok {
+		if err := p.Ping(r.Context()); err != nil {
+			writeJSON(w, http.StatusServiceUnavailable, map[string]any{
+				"status": "unavailable",
+				"reason": err.Error(),
+			})
+			return
+		}
+	}
+	writeJSON(w, http.StatusOK, map[string]string{"status": "ok"})
+}