refactor: replace custom request/response types with chi router

Eliminate the hand-rolled Request/Response abstraction layer in favor of
a standard net/http + chi router. All entry points (server, lambda,
verify, sample) now construct stdlib *http.Request objects and route them
through a shared chi handler returned by App.Handler(). This removes the
custom HandleRequest dispatcher, consolidates routing and middleware
(admin auth, panic recovery), and makes tests more realistic by
exercising the actual router via httptest.

Author: sgtoj

cmd/lambda/main.go

@@ -1,9 +1,13 @@
 package main
 
 import (
+	"bytes"
 	"context"
 	"encoding/json"
+	"fmt"
 	"log/slog"
+	"net/http"
+	"net/http/httptest"
 	"strings"
 	"sync"
 
@@ -17,6 +21,7 @@ import (
 var (
 	initOnce sync.Once
 	appInst  *app.App
+	router   http.Handler
 	logger   *slog.Logger
 	initErr  error
 )
@@ -31,10 +36,15 @@ func initApp() {
 			return
 		}
 		appInst, initErr = app.NewApp(context.Background(), cfg, logger)
+		if initErr != nil {
+			return
+		}
+		router = appInst.Handler()
 	})
 }
 
-// APIGatewayHandler converts API Gateway requests to unified app.Request.
+// APIGatewayHandler converts API Gateway requests to stdlib *http.Request
+// and routes them through the chi router.
 func APIGatewayHandler(ctx context.Context, req awsevents.APIGatewayV2HTTPRequest) (awsevents.APIGatewayV2HTTPResponse, error) {
 	initApp()
 	if initErr != nil {
@@ -50,29 +60,35 @@ func APIGatewayHandler(ctx context.Context, req awsevents.APIGatewayV2HTTPReques
 		logger.Debug("received api gateway request", slog.String("request", string(j)))
 	}
 
-	headers := make(map[string]string)
-	for key, value := range req.Headers {
-		headers[strings.ToLower(key)] = value
+	httpReq, err := http.NewRequestWithContext(
+		ctx,
+		req.RequestContext.HTTP.Method,
+		req.RawPath,
+		strings.NewReader(req.Body),
+	)
+	if err != nil {
+		return awsevents.APIGatewayV2HTTPResponse{
+			StatusCode: 500,
+			Body:       "failed to construct http request",
+		}, nil
 	}
 
-	appReq := app.Request{
-		Type:    app.RequestTypeHTTP,
-		Method:  req.RequestContext.HTTP.Method,
-		Path:    req.RawPath,
-		Headers: headers,
-		Body:    []byte(req.Body),
+	for key, value := range req.Headers {
+		httpReq.Header.Set(key, value)
 	}
 
-	resp := appInst.HandleRequest(ctx, appReq)
+	rec := httptest.NewRecorder()
+	router.ServeHTTP(rec, httpReq)
 
 	return awsevents.APIGatewayV2HTTPResponse{
-		StatusCode: resp.StatusCode,
-		Headers:    resp.Headers,
-		Body:       string(resp.Body),
+		StatusCode: rec.Code,
+		Headers:    flattenHeaders(rec.Header()),
+		Body:       rec.Body.String(),
 	}, nil
 }
 
-// EventBridgeHandler converts EventBridge events to unified app.Request.
+// EventBridgeHandler converts EventBridge events to POST /scheduled/{action}
+// requests and routes them through the chi router.
 func EventBridgeHandler(ctx context.Context, evt awsevents.CloudWatchEvent) error {
 	initApp()
 	if initErr != nil {
@@ -90,16 +106,30 @@ func EventBridgeHandler(ctx context.Context, evt awsevents.CloudWatchEvent) erro
 		return err
 	}
 
-	req := app.Request{
-		Type:            app.RequestTypeScheduled,
-		ScheduledAction: detail.Action,
-		ScheduledData:   detail.Data,
+	path := fmt.Sprintf("%s/scheduled/%s", appInst.Config.BasePath, detail.Action)
+
+	var body []byte
+	if detail.Data != nil {
+		body = detail.Data
 	}
 
-	resp := appInst.HandleRequest(ctx, req)
+	httpReq, err := http.NewRequestWithContext(ctx, http.MethodPost, path, bytes.NewReader(body))
+	if err != nil {
+		return errors.Wrap(err, "failed to construct http request")
+	}
 
-	if resp.StatusCode >= 400 {
-		return errors.Newf("scheduled event failed: %s", string(resp.Body))
+	if appInst.Config.AdminToken != "" {
+		httpReq.Header.Set("Authorization", "Bearer "+appInst.Config.AdminToken)
+	}
+	if len(body) > 0 {
+		httpReq.Header.Set("Content-Type", "application/json")
+	}
+
+	rec := httptest.NewRecorder()
+	router.ServeHTTP(rec, httpReq)
+
+	if rec.Code >= 400 {
+		return errors.Newf("scheduled event failed: %s", rec.Body.String())
 	}
 
 	return nil
@@ -125,6 +155,17 @@ func UniversalHandler(ctx context.Context, event json.RawMessage) (any, error) {
 	return nil, errors.New("unknown lambda event type")
 }
 
+// flattenHeaders converts multi-value http.Header to single-value map.
+func flattenHeaders(h http.Header) map[string]string {
+	flat := make(map[string]string, len(h))
+	for key, values := range h {
+		if len(values) > 0 {
+			flat[key] = values[0]
+		}
+	}
+	return flat
+}
+
 func main() {
 	lambda.Start(UniversalHandler)
 }

cmd/sample/main.go

@@ -4,9 +4,13 @@
 package main
 
 import (
+	"bytes"
 	"context"
 	"encoding/json"
+	"fmt"
 	"log/slog"
+	"net/http"
+	"net/http/httptest"
 	"os"
 	"path/filepath"
 
@@ -38,6 +42,8 @@ func main() {
 		os.Exit(1)
 	}
 
+	router := a.Handler()
+
 	path := filepath.Join("fixtures", "samples.json")
 	raw, err := os.ReadFile(path)
 	if err != nil {
@@ -60,24 +66,45 @@ func main() {
 
 		switch eventType {
 		case "okta_sync":
-			evt := app.ScheduledEvent{
-				Action: "okta-sync",
+			reqPath := fmt.Sprintf("%s/scheduled/okta-sync", cfg.BasePath)
+			httpReq, err := http.NewRequestWithContext(ctx, http.MethodPost, reqPath, nil)
+			if err != nil {
+				logger.Error("failed to construct http request",
+					slog.Int("sample", i),
+					slog.String("error", err.Error()))
+				os.Exit(1)
+			}
+			if cfg.AdminToken != "" {
+				httpReq.Header.Set("Authorization", "Bearer "+cfg.AdminToken)
 			}
-			if err := a.ProcessScheduledEvent(ctx, evt); err != nil {
+			rec := httptest.NewRecorder()
+			router.ServeHTTP(rec, httpReq)
+			if rec.Code >= 400 {
 				logger.Error("failed to process okta_sync sample",
 					slog.Int("sample", i),
-					slog.String("error", err.Error()))
+					slog.String("response", rec.Body.String()))
 				os.Exit(1)
 			}
 
 		case "pr_webhook":
 			payload, _ := json.Marshal(sample["payload"])
-			if err := a.ProcessWebhook(ctx, payload, "pull_request"); err != nil {
-				logger.Error("failed to process pr_webhook sample",
+			reqPath := fmt.Sprintf("%s/webhooks", cfg.BasePath)
+			httpReq, err := http.NewRequestWithContext(ctx, http.MethodPost, reqPath, bytes.NewReader(payload))
+			if err != nil {
+				logger.Error("failed to construct http request",
 					slog.Int("sample", i),
 					slog.String("error", err.Error()))
 				os.Exit(1)
 			}
+			httpReq.Header.Set("X-GitHub-Event", "pull_request")
+			rec := httptest.NewRecorder()
+			router.ServeHTTP(rec, httpReq)
+			if rec.Code >= 400 {
+				logger.Error("failed to process pr_webhook sample",
+					slog.Int("sample", i),
+					slog.String("response", rec.Body.String()))
+				os.Exit(1)
+			}
 
 		default:
 			logger.Info("skipping unknown event type", slog.String("event_type", eventType))

cmd/server/main.go

@@ -2,26 +2,19 @@ package main
 
 import (
 	"context"
-	"io"
 	"log/slog"
 	"net/http"
 	"os"
 	"os/signal"
-	"strings"
 	"syscall"
 	"time"
 
 	"github.com/cruxstack/github-ops-app/internal/app"
 	"github.com/cruxstack/github-ops-app/internal/config"
 )
 
-var (
-	appInst *app.App
-	logger  *slog.Logger
-)
-
 func main() {
-	logger = config.NewLogger()
+	logger := config.NewLogger()
 	ctx := context.Background()
 
 	cfg, err := config.NewConfig()
@@ -30,23 +23,20 @@ func main() {
 		os.Exit(1)
 	}
 
-	appInst, err = app.NewApp(ctx, cfg, logger)
+	appInst, err := app.NewApp(ctx, cfg, logger)
 	if err != nil {
 		logger.Error("app init failed", slog.String("error", err.Error()))
 		os.Exit(1)
 	}
 
-	mux := http.NewServeMux()
-	mux.HandleFunc("/", httpHandler)
-
 	port := os.Getenv("APP_PORT")
 	if port == "" {
 		port = "8080"
 	}
 
 	srv := &http.Server{
 		Addr:         ":" + port,
-		Handler:      mux,
+		Handler:      appInst.Handler(),
 		ReadTimeout:  15 * time.Second,
 		WriteTimeout: 15 * time.Second,
 		IdleTimeout:  60 * time.Second,
@@ -80,42 +70,3 @@ func main() {
 	<-done
 	logger.Info("server stopped")
 }
-
-// httpHandler converts http.Request to app.Request and handles the response.
-func httpHandler(w http.ResponseWriter, r *http.Request) {
-	defer r.Body.Close()
-	body, err := io.ReadAll(io.LimitReader(r.Body, 10<<20)) // 10MB limit
-	if err != nil {
-		http.Error(w, "failed to read request body", http.StatusBadRequest)
-		return
-	}
-
-	headers := make(map[string]string)
-	for key, values := range r.Header {
-		if len(values) > 0 {
-			headers[strings.ToLower(key)] = values[0]
-		}
-	}
-
-	req := app.Request{
-		Type:    app.RequestTypeHTTP,
-		Method:  r.Method,
-		Path:    r.URL.Path,
-		Headers: headers,
-		Body:    body,
-	}
-
-	resp := appInst.HandleRequest(r.Context(), req)
-
-	for key, value := range resp.Headers {
-		w.Header().Set(key, value)
-	}
-	if resp.ContentType != "" && w.Header().Get("Content-Type") == "" {
-		w.Header().Set("Content-Type", resp.ContentType)
-	}
-
-	w.WriteHeader(resp.StatusCode)
-	if len(resp.Body) > 0 {
-		w.Write(resp.Body)
-	}
-}