Sujunk ir aptarnauk — static, handlers, router, main

Keturi failai kaip skirtukai, priklausomybių tvarka: static/embed.go → handlers.go → router.go → main.go — įterpk išteklius, atvaizduok šabloną, aptarnauk /static, sujunk main. Paskutiniai trys — tavo 1 pamokos failų pakeitimai: diff rodo tik pakeistas eilutes, visa kita perkelta.

1. static/embed.go (naujas) — padaro išteklius dvejetainio dalimi:

//go:embed assets
var FS embed.FS

CSS ir vietinis htmx gyvena po static/assets/css/style.css ir static/assets/js/htmx.min.js. Šie du — pateikti ištekliai — šis kursas moko Go ir HTML, tad stilių lapas ateina su starteriu (kaip dizaino sistema, kurią gautum darbe); gali jį laisvai keisti. //go:embed įkepa juos į sukompiliuotą dvejetainį, tad nėra atskiro išteklių aplanko, kurį diegti.

2. internal/handlers/handlers.go (modify) — Home dabar atvaizduoja šabloną. Vienintelė pakeista funkcija:

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

Neapdorotos eilutės fmt.Fprint nebėra; su ja — ir fmt importas, o vietoj jo importuojamas web. Health ir struktūra nepakito.

3. internal/handlers/router.go (modify) — vienas naujas maršrutas ir vienas naujas parametras:

func (h *Handlers) Router(staticFS fs.FS) http.Handler {   // ← dabar ima išteklių FS
	// ... tie patys middleware ...
	r.Handle("/static/*", http.StripPrefix("/static/", http.FileServer(http.FS(staticFS))))
	// ... / ir /healthz nepakito ...
}

4. cmd/signflow/main.go (modify) — išgauk po-FS ir paduok jį maršrutizatoriui:

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

Patikrink. Iš naujo sugeneruok šablonus, tada paleisk:

templ generate
go run ./cmd/signflow

Atsidaryk http://localhost:8080. Tas pats turinys kaip 1 pamokoje — bet dabar tai tikras, stilizuotas puslapis: SignFlow antraštė, hero, „Skeleton status" kortelė, visi apsirengę stilių lapu. Peržiūrėk šaltinį — pamatysi visą HTML, kurį sukūrė maketas. Ir:

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

CSS aptarnaujamas iš dvejetainio vidaus.

Spąstai (pakartojimas — pasenęs šablonas). Pakeitei home.templ, perkrovei, pokyčio nematyti? Praleidai templ generate. Dvejetainis atvaizduoja komituotą _templ.go, ne tavo pakeistą .templ. Sugeneruok, perkompiliuok, perkrauk.

embed.go SUKURTI

Sukurk šį failą kataloge 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 MODIFIKUOTI 3 eilutės pakeistos

Redaguok šį failą kataloge 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 MODIFIKUOTI 7 eilutės pakeistos

Redaguok šį failą kataloge 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 MODIFIKUOTI 9 eilutės pakeistos

Redaguok šį failą kataloge 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)
}