nexarch/workflow/internal/moduleadapter/handler.go

package moduleadapter

import (
	"encoding/json"
	"errors"
	"net/http"

	"github.com/jackc/pgx/v5/pgxpool"

	"gitea.perlbach24.de/scripte/nexarch/workflow/internal/svcauth"
)

// Server bindet die Registrierungs-API an einen Postgres-Pool und
// verlangt ein Service-Token bei jedem Aufruf (fail closed: ein leeres
// oder falsches Token wird immer abgewiesen, Lehre aus RET-14/F-08).
type Server struct {
	pool         *pgxpool.Pool
	serviceToken string
}

func NewServer(pool *pgxpool.Pool, serviceToken string) *Server {
	return &Server{pool: pool, serviceToken: serviceToken}
}

func (s *Server) RegisterRoutes(mux *http.ServeMux) {
	mux.HandleFunc("POST /register", s.requireAuth(s.handleRegister))
	mux.HandleFunc("POST /rollback", s.requireAuth(s.handleRollback))
	mux.HandleFunc("POST /deregister", s.requireAuth(s.handleDeregister))
	mux.HandleFunc("GET /registrations", s.requireAuth(s.handleList))
	mux.HandleFunc("POST /events", s.requireAuth(s.handlePublishEvent))
}

func (s *Server) requireAuth(next http.HandlerFunc) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		got := r.Header.Get("X-Service-Token")
		if !svcauth.Equal(got, s.serviceToken) {
			writeError(w, http.StatusUnauthorized, "service-token fehlt oder ist ungueltig")
			return
		}
		next(w, r)
	}
}

type registerRequest struct {
	ModuleName string   `json:"module_name"`
	ObjectType string   `json:"object_type"`
	Triggers   []string `json:"triggers"`
}

func (s *Server) handleRegister(w http.ResponseWriter, r *http.Request) {
	var req registerRequest
	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
		writeError(w, http.StatusBadRequest, "ungueltiger anfrage-koerper")
		return
	}
	reg, err := Register(r.Context(), s.pool, req.ModuleName, req.ObjectType, req.Triggers)
	if errors.Is(err, ErrDuplicateTriggers) {
		writeError(w, http.StatusConflict, "registrierung unveraendert, keine neue version noetig")
		return
	}
	if err != nil {
		writeError(w, http.StatusBadRequest, err.Error())
		return
	}
	writeJSON(w, http.StatusOK, reg)
}

type rollbackRequest struct {
	ModuleName string `json:"module_name"`
	ObjectType string `json:"object_type"`
	ToVersion  int    `json:"to_version"`
}

func (s *Server) handleRollback(w http.ResponseWriter, r *http.Request) {
	var req rollbackRequest
	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
		writeError(w, http.StatusBadRequest, "ungueltiger anfrage-koerper")
		return
	}
	reg, err := Rollback(r.Context(), s.pool, req.ModuleName, req.ObjectType, req.ToVersion)
	if errors.Is(err, ErrNotRegistered) {
		writeError(w, http.StatusNotFound, "objekttyp ist nicht registriert")
		return
	}
	if err != nil {
		writeError(w, http.StatusBadRequest, err.Error())
		return
	}
	writeJSON(w, http.StatusOK, reg)
}

type deregisterRequest struct {
	ModuleName string `json:"module_name"`
	ObjectType string `json:"object_type"`
}

func (s *Server) handleDeregister(w http.ResponseWriter, r *http.Request) {
	var req deregisterRequest
	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
		writeError(w, http.StatusBadRequest, "ungueltiger anfrage-koerper")
		return
	}
	err := Deregister(r.Context(), s.pool, req.ModuleName, req.ObjectType)
	if errors.Is(err, ErrNotRegistered) {
		writeError(w, http.StatusNotFound, "objekttyp ist nicht registriert")
		return
	}
	if err != nil {
		writeError(w, http.StatusInternalServerError, "deregistrierung fehlgeschlagen")
		return
	}
	w.WriteHeader(http.StatusNoContent)
}

func (s *Server) handleList(w http.ResponseWriter, r *http.Request) {
	regs, err := ListRegistrations(r.Context(), s.pool)
	if err != nil {
		writeError(w, http.StatusInternalServerError, "registrierungen konnten nicht gelesen werden")
		return
	}
	writeJSON(w, http.StatusOK, regs)
}

type publishEventRequest struct {
	ModuleName string          `json:"module_name"`
	ObjectType string          `json:"object_type"`
	Trigger    string          `json:"trigger"`
	ObjectID   string          `json:"object_id"`
	Payload    json.RawMessage `json:"payload"`
}

func (s *Server) handlePublishEvent(w http.ResponseWriter, r *http.Request) {
	var req publishEventRequest
	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
		writeError(w, http.StatusBadRequest, "ungueltiger anfrage-koerper")
		return
	}
	err := PublishEvent(r.Context(), s.pool, Event{
		ModuleName: req.ModuleName,
		ObjectType: req.ObjectType,
		Trigger:    req.Trigger,
		ObjectID:   req.ObjectID,
		Payload:    req.Payload,
	})
	if err != nil {
		writeError(w, http.StatusBadRequest, err.Error())
		return
	}
	w.WriteHeader(http.StatusAccepted)
}

func writeJSON(w http.ResponseWriter, status int, v any) {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(status)
	_ = json.NewEncoder(w).Encode(v)
}

func writeError(w http.ResponseWriter, status int, message string) {
	writeJSON(w, status, map[string]string{"error": message})
}