refactor: new router module to comicverse app

comicverse.go

@@ -9,6 +9,7 @@ import (
 	"log/slog"
 	"net/http"
 
+	"forge.capytal.company/capytalcode/project-comicverse/router"
 	"forge.capytal.company/loreddev/x/tinyssert"
 )
 
@@ -66,6 +67,8 @@ func WithDevelopmentMode() Option {
 }
 
 type app struct {
+	handler http.Handler
+
 	developmentMode bool
 	context         context.Context
 
@@ -78,7 +81,19 @@ func (app *app) setup() error {
 	app.assert.NotNil(app.logger)
 
 	var err error
+
+	app.handler, err = router.New(router.Config{
+		DisableCache: app.developmentMode,
+		Assertions: app.assert,
+		Logger:     app.logger,
+	})
+	if err != nil {
+		return errors.Join(errors.New("unable to initiate router"), err)
+	}
+
 	return err
 }
 func (app *app) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+	app.assert.NotNil(app.handler)
+	app.handler.ServeHTTP(w, r)
 }

router/router.go

@@ -11,33 +11,67 @@ import (
 	"forge.capytal.company/loreddev/x/tinyssert"
 )
 
-func New(assertions tinyssert.Assertions, log *slog.Logger, dev bool) http.Handler {
+type router struct {
+	cache       bool
+
+	assert tinyssert.Assertions
+	log    *slog.Logger
+}
+
+func New(cfg Config) (http.Handler, error) {
+	if cfg.Assertions == nil {
+		return nil, errors.New("assertions is nil")
+	}
+	if cfg.Logger == nil {
+		return nil, errors.New("logger is nil")
+	}
+
+	r := &router{
+		cache:  !cfg.DisableCache,
+		assert: cfg.Assertions,
+		log:    cfg.Logger,
+	}
+
+	return r.setup(), nil
+}
+
+type Config struct {
+	DisableCache bool
+
+	Assertions tinyssert.Assertions
+	Logger     *slog.Logger
+}
+
+func (router *router) setup() http.Handler {
+	router.assert.NotNil(router.log)
+
+	log := router.log
+
+	log.Debug("Initializing router")
+
 	r := smalltrip.NewRouter(
-		smalltrip.WithAssertions(assertions),
+		smalltrip.WithAssertions(router.assert),
 		smalltrip.WithLogger(log.WithGroup("smalltrip")),
 	)
 
 	r.Use(middleware.Logger(log.WithGroup("requests")))
-	if dev {
-		log.Debug("Development mode activated, using development middleware")
-		r.Use(middleware.Dev)
+	if router.cache {
+		r.Use(middleware.Cache())
 	} else {
-		r.Use(middleware.PersistentCache())
+		r.Use(middleware.DisableCache())
 	}
+
 	r.Use(exception.PanicMiddleware())
 	r.Use(exception.Middleware())
 
-	r.HandleFunc("/dashboard", func(w http.ResponseWriter, r *http.Request) {
-		w.WriteHeader(http.StatusOK)
-		err := templates.Templates().ExecuteTemplate(w, "dashboard", nil)
-		if err != nil {
-			exception.InternalServerError(err).ServeHTTP(w, r)
-		}
-	})
-	r.Handle("/static/", http.StripPrefix("/static/", http.FileServer(http.Dir("./static"))))
+	r.HandleFunc("/dashboard", router.dashboard)
 
 	return r
 }
 
-func dashboard(w http.ResponseWriter, r *http.Request) {
+func (router *router) dashboard(w http.ResponseWriter, r *http.Request) {
+	router.assert.NotNil(w)
+	router.assert.NotNil(r)
+
+	w.WriteHeader(http.StatusOK)
 }