initial

server/handler/handler.go

@@ -0,0 +1,24 @@
+package handler
+
+import (
+	"context"
+	"github.com/a-h/templ"
+	"vctp/db"
+	"log/slog"
+	"net/http"
+)
+
+// Handler handles requests.
+type Handler struct {
+	Logger   *slog.Logger
+	Database db.Database
+}
+
+func (h *Handler) html(ctx context.Context, w http.ResponseWriter, status int, t templ.Component) {
+	w.Header().Set("Content-Type", "text/html; charset=utf-8")
+	w.WriteHeader(status)
+
+	if err := t.Render(ctx, w); err != nil {
+		h.Logger.Error("Failed to render component", "error", err)
+	}
+}

server/handler/home.go

@@ -0,0 +1,12 @@
+package handler
+
+import (
+	"vctp/components/core"
+	"vctp/components/home"
+	"net/http"
+)
+
+// Home handles the home page.
+func (h *Handler) Home(w http.ResponseWriter, r *http.Request) {
+	h.html(r.Context(), w, http.StatusOK, core.HTML("Example Site", home.Home()))
+}

server/middleware/cache.go

@@ -0,0 +1,18 @@
+package middleware
+
+import (
+	"vctp/version"
+	"net/http"
+)
+
+// CacheMiddleware sets the Cache-Control header based on the version.
+func CacheMiddleware(next http.Handler) http.Handler {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if version.Value == "dev" {
+			w.Header().Set("Cache-Control", "no-cache")
+		} else {
+			w.Header().Set("Cache-Control", "public, max-age=31536000")
+		}
+		next.ServeHTTP(w, r)
+	})
+}

server/middleware/logging.go

@@ -0,0 +1,34 @@
+package middleware
+
+import (
+	"log/slog"
+	"net/http"
+	"time"
+)
+
+// LoggingMiddleware represents a logging middleware.
+type LoggingMiddleware struct {
+	logger  *slog.Logger
+	handler http.Handler
+}
+
+// NewLoggingMiddleware creates a new logging middleware with the given logger and handler.
+func NewLoggingMiddleware(logger *slog.Logger, handler http.Handler) *LoggingMiddleware {
+	return &LoggingMiddleware{
+		logger:  logger,
+		handler: handler,
+	}
+}
+
+// ServeHTTP logs the request and calls the next handler.
+func (l *LoggingMiddleware) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+	start := time.Now()
+	l.handler.ServeHTTP(w, r)
+	l.logger.Debug(
+		"Request recieved",
+		slog.String("method", r.Method),
+		slog.String("path", r.URL.Path),
+		slog.String("remote", r.RemoteAddr),
+		slog.Duration("duration", time.Since(start)),
+	)
+}

server/middleware/middleware.go

@@ -0,0 +1,22 @@
+package middleware
+
+import "net/http"
+
+type Handler func(http.Handler) http.Handler
+
+func Chain(handlers ...Handler) Handler {
+	if len(handlers) == 0 {
+		return defaultHandler
+	}
+
+	return func(next http.Handler) http.Handler {
+		for i := len(handlers) - 1; i >= 0; i-- {
+			next = handlers[i](next)
+		}
+		return next
+	}
+}
+
+func defaultHandler(next http.Handler) http.Handler {
+	return next
+}

server/router/router.go

@@ -0,0 +1,24 @@
+package router
+
+import (
+	"vctp/db"
+	"vctp/dist"
+	"vctp/server/handler"
+	"vctp/server/middleware"
+	"log/slog"
+	"net/http"
+)
+
+func New(logger *slog.Logger, database db.Database) http.Handler {
+	h := &handler.Handler{
+		Logger:   logger,
+		Database: database,
+	}
+
+	mux := http.NewServeMux()
+
+	mux.Handle("/assets/", middleware.CacheMiddleware(http.FileServer(http.FS(dist.AssetsDir))))
+	mux.HandleFunc("/", h.Home)
+
+	return middleware.NewLoggingMiddleware(logger, mux)
+}

server/server.go

@@ -0,0 +1,96 @@
+package server
+
+import (
+	"context"
+	"log/slog"
+	"net/http"
+	"os"
+	"os/signal"
+	"time"
+)
+
+// Server represents an HTTP server.
+type Server struct {
+	srv    *http.Server
+	logger *slog.Logger
+}
+
+// New creates a new server with the given logger, address and options.
+func New(logger *slog.Logger, addr string, opts ...Option) *Server {
+	srv := &http.Server{
+		Addr:         addr,
+		WriteTimeout: 15 * time.Second,
+		ReadTimeout:  15 * time.Second,
+	}
+	for _, opt := range opts {
+		opt(&Server{srv: srv})
+	}
+
+	return &Server{
+		srv:    srv,
+		logger: logger,
+	}
+}
+
+// Option represents a server option.
+type Option func(*Server)
+
+// WithWriteTimeout sets the write timeout.
+func WithWriteTimeout(timeout time.Duration) Option {
+	return func(s *Server) {
+		s.srv.WriteTimeout = timeout
+	}
+}
+
+// WithReadTimeout sets the read timeout.
+func WithReadTimeout(timeout time.Duration) Option {
+	return func(s *Server) {
+		s.srv.ReadTimeout = timeout
+	}
+}
+
+// WithRouter sets the handler.
+func WithRouter(handler http.Handler) Option {
+	return func(s *Server) {
+		s.srv.Handler = handler
+	}
+}
+
+// StartAndWait starts the server and waits for a signal to shut down.
+func (s *Server) StartAndWait() {
+	s.Start()
+	s.GracefulShutdown()
+}
+
+// Start starts the server.
+func (s *Server) Start() {
+	go func() {
+		s.logger.Info("starting server", "port", s.srv.Addr)
+		if err := s.srv.ListenAndServe(); err != nil {
+			s.logger.Warn("failed to start server", "error", err)
+		}
+	}()
+}
+
+// GracefulShutdown shuts down the server gracefully.
+func (s *Server) GracefulShutdown() {
+	c := make(chan os.Signal, 1)
+	// We'll accept graceful shutdowns when quit via SIGINT (Ctrl+C)
+	// SIGKILL, SIGQUIT or SIGTERM (Ctrl+/) will not be caught.
+	signal.Notify(c, os.Interrupt)
+
+	// Block until we receive our signal.
+	<-c
+
+	// Create a deadline to wait for.
+	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+	defer cancel()
+	// Doesn't block if no connections, but will otherwise wait
+	// until the timeout deadline.
+	_ = s.srv.Shutdown(ctx)
+	// Optionally, you could run srv.Shutdown in a goroutine and block on
+	// <-ctx.Done() if your application should wait for other services
+	// to finalize based on context cancellation.
+	s.logger.Info("shutting down")
+	os.Exit(0)
+}