Templ — type-safe compiled templates

Code

Wire it up + serve assets — static, handlers, router, main

Four files as tabs, in dependency order: static/embed.go → handlers.go → router.go → main.go — embed the assets, render the template, serve /static, wire it in main. The last three are modifications of your lesson-1 files: the diff shows only the changed lines, everything else is carried forward.

1. static/embed.go (new) — makes the assets part of the binary:

//go:embed assets
var FS embed.FS

The CSS and vendored htmx live under static/assets/css/style.css and static/assets/js/htmx.min.js. Those two are provided assets — this course teaches Go and HTML, so the stylesheet ships with the starter (like a design system you'd be handed at work); you're welcome to edit it. //go:embed bakes them into the compiled binary, so there's no separate asset folder to deploy.

2. internal/handlers/handlers.go (modify) — Home now renders the template. The one changed function:

func (h *Handlers) Home(w http.ResponseWriter, r *http.Request) {
	render(w, r, http.StatusOK, web.Home())
}

The raw-string fmt.Fprint is gone; the fmt import with it, and web is imported instead. Health and the struct are unchanged.

3. internal/handlers/router.go (modify) — one new route and one new parameter:

func (h *Handlers) Router(staticFS fs.FS) http.Handler {   // ← now takes the asset FS
	// ... the same middleware ...
	r.Handle("/static/*", http.StripPrefix("/static/", http.FileServer(http.FS(staticFS))))
	// ... / and /healthz unchanged ...
}

4. cmd/signflow/main.go (modify) — derive the sub-FS and hand it to the router:

staticFS, err := fs.Sub(static.FS, "assets")   // expose static/assets at /static
if err != nil {
	return err
}
// ...
Handler: h.Router(staticFS),

Verify. Regenerate the templates, then run:

templ generate
go run ./cmd/signflow

Open http://localhost:8080. Same content as lesson 1 — but now it's a real, styled page: the SignFlow header, the hero, the "Skeleton status" card, all wearing the stylesheet. View source and you'll see the full HTML the layout produced. And:

$ curl -s -o /dev/null -w "%{http_code}\n" localhost:8080/static/css/style.css
200

The CSS is served from inside the binary.

Gotcha (recap — the stale template). Change home.templ, reload, see no change? You skipped templ generate. The binary renders the committed _templ.go, not your edited .templ. Generate, rebuild, reload.

embed.go CREATE

Create this file in static/

// Package static embeds the CSS and vendored JS so the binary is fully
// self-contained — no separate asset directory to deploy.
package static

import "embed"

//go:embed assets
var FS embed.FS

handlers.go MODIFY 3 lines changed

Edit this file in internal/handlers/

// Package handlers holds the HTTP handlers. In this skeleton there is only the
// home page and a health check; later lessons add auth, documents, and signing.
package handlers

import (
	"log/slog"
	"net/http"

	"github.com/programuoki/signflow/internal/config"
	"github.com/programuoki/signflow/internal/web"
)

// Handlers bundles the dependencies every handler needs. Constructed once in
// main; its methods are registered on the router. It gains fields as the app
// grows (a database in lesson 3, sessions in lesson 4, ...).
type Handlers struct {
	Cfg config.Config
	Log *slog.Logger
}

func New(cfg config.Config, log *slog.Logger) *Handlers {
	return &Handlers{Cfg: cfg, Log: log}
}

// Home renders the landing page from a type-safe Templ template.
func (h *Handlers) Home(w http.ResponseWriter, r *http.Request) {
	render(w, r, http.StatusOK, web.Home())
}

// Health is a plain-text liveness probe for Railway / uptime checks.
func (h *Handlers) Health(w http.ResponseWriter, r *http.Request) {
	w.Header().Set("Content-Type", "text/plain")
	_, _ = w.Write([]byte("ok"))
}

router.go MODIFY 7 lines changed

Edit this file in internal/handlers/

package handlers

import (
	"io/fs"
	"net/http"

	"github.com/go-chi/chi/v5"
	"github.com/go-chi/chi/v5/middleware"
)

// Router builds the Chi router with the base middleware stack and serves the
// embedded static assets. Auth-protected route groups are added in lesson 5.
func (h *Handlers) Router(staticFS fs.FS) http.Handler {
	r := chi.NewRouter()

	// Base middleware, outermost first.
	r.Use(middleware.RequestID)
	r.Use(middleware.RealIP)
	r.Use(middleware.Logger)    // request logging
	r.Use(middleware.Recoverer) // turn panics into 500s instead of crashing

	// Static assets (CSS, vendored htmx), served from the embedded FS.
	r.Handle("/static/*", http.StripPrefix("/static/", http.FileServer(http.FS(staticFS))))

	r.Get("/", h.Home)
	r.Get("/healthz", h.Health)

	return r
}

main.go MODIFY 9 lines changed

Edit this file in cmd/signflow/

// Command signflow is the HTTP server entrypoint. On startup it loads config,
// builds the Chi router, and serves with graceful shutdown. Lesson 3 adds the
// database (migrations + a connection pool) between config and serving.
package main

import (
	"context"
	"errors"
	"io/fs"
	"log/slog"
	"net/http"
	"os"
	"os/signal"
	"syscall"
	"time"

	"github.com/programuoki/signflow/internal/config"
	"github.com/programuoki/signflow/internal/handlers"
	"github.com/programuoki/signflow/static"
)

func main() {
	log := slog.New(slog.NewTextHandler(os.Stdout, &slog.HandlerOptions{Level: slog.LevelInfo}))
	if err := run(log); err != nil {
		log.Error("fatal", "err", err)
		os.Exit(1)
	}
}

func run(log *slog.Logger) error {
	cfg, err := config.Load()
	if err != nil {
		return err
	}
	log.Info("starting signflow", "env", cfg.Env, "port", cfg.Port, "base_url", cfg.BaseURL)

	h := handlers.New(cfg, log)

	// The assets live under static/assets; expose that subtree at /static.
	staticFS, err := fs.Sub(static.FS, "assets")
	if err != nil {
		return err
	}

	srv := &http.Server{
		Addr:              ":" + cfg.Port,
		Handler:           h.Router(staticFS),
		ReadHeaderTimeout: 10 * time.Second,
	}

	// Graceful shutdown: stop accepting on SIGINT/SIGTERM, then drain in-flight
	// requests for up to 15s before exiting.
	shutdownCtx, stop := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM)
	defer stop()

	go func() {
		log.Info("listening", "addr", srv.Addr)
		if err := srv.ListenAndServe(); err != nil && !errors.Is(err, http.ErrServerClosed) {
			log.Error("server error", "err", err)
			stop()
		}
	}()

	<-shutdownCtx.Done()
	log.Info("shutting down")

	timeout, cancel := context.WithTimeout(context.Background(), 15*time.Second)
	defer cancel()
	return srv.Shutdown(timeout)
}