Sujunk bazę — main, handlers, home

Dabar sujunk dalis. Trys pakeitimai, skirtukai, sekant duomenis nuo šaltinio į išorę: main.go → handlers.go → home.templ (paleisk bazę, duok apdorotojams užklausas, parodyk skaičių). Diff'ai rodo tik tai, kas pasikeitė; viskas iš 1–2 pamokų perkelta.

1. cmd/signflow/main.go (modify) — tarp config ir aptarnavimo įsiterpia du žingsniai: paleidžiam migracijas, tada atidarom telkinį.

if err := runMigrations(cfg.DatabaseURL, log); err != nil {   // goose Up, įterptos
	return err
}
pool, err := db.Connect(ctx, cfg.DatabaseURL)                 // pgx telkinys
// ...
queries := db.New(pool)
h := handlers.New(cfg, queries, log)                          // ← dabar ima queries

runMigrations naudoja goose database/sql rankeną (per pgx stdlib tvarkyklę) įterptoms migracijoms pritaikyti, tada programa veikia ant pgx telkinio. Statinių failų / aptarnavimo / išjungimo kodas žemiau nepakito.

2. internal/handlers/handlers.go (modify) — struktūra gauna Queries lauką, New jį ima, o Home nuskaito skaičių:

count, err := h.Queries.CountUsers(r.Context())
// ...
render(w, r, http.StatusOK, web.Home(count))

Health dabar taip pat pingina bazę — nepasiekiama bazė praneša 503 nesveika, o ne tyliai aptarnauja 500-us.

3. internal/web/home.templ (modify) — Home užsiaugina parametrą ir eilutę:

templ Home(userCount int64) {          // ← buvo Home()
	...
	Registered users in the database: <strong>{ strconv.FormatInt(userCount, 10) }</strong>

Patikrink. Sukurk bazę, tada paleisk (atmink: templ generate dėl home pakeitimo, sqlc generate, jei dar nepaleidai):

createdb signflow
templ generate
go run ./cmd/signflow

Paleidimas dabar užrašo pritaikomą migraciją:

level=INFO msg="starting signflow" env=dev port=8080 base_url=http://localhost:8080
level=INFO msg=goose msg="OK   00001_users.sql"
level=INFO msg=listening addr=:8080

Atsidaryk http://localhost:8080 — būsenos kortelė dabar rodo „Registered users in the database: 0", gyvai iš Postgres. Įterpk vieną ranka ir perkrauk:

$ psql signflow -c "INSERT INTO users (email, password_hash) VALUES ('a@b.co', 'x');"
INSERT 0 1

Perkrauk puslapį → „Registered users in the database: 1". Skaičius atėjo iš bazės per tavo sqlc sugeneruotą CountUsers į tipiškai saugų šabloną. Visas stekas sujungtas.

Spąstai (migracija jau pritaikyta). Paleisk go run du kartus — antras paleidimas neužrašo OK 00001_users.sql: goose įsimena pritaikytas migracijas goose_db_version lentelėje ir jas praleidžia. Būtent to ir norim: migracijos taikomos vieną kartą ir jas saugu paleisti kiekvieną kartą startuojant. Norint pradėti švariai: dropdb signflow && createdb signflow.

main.go MODIFIKUOTI 57 eilutės pakeistos

Redaguok šį failą kataloge cmd/signflow/

// Command signflow is the HTTP server entrypoint.
//
// On startup it: loads config, runs embedded goose migrations, opens a pgx
// pool, builds the Chi router, and serves with graceful shutdown.
package main

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

	"github.com/jackc/pgx/v5/stdlib"
	"github.com/pressly/goose/v3"

	migrations "github.com/programuoki/signflow/db"
	"github.com/programuoki/signflow/internal/config"
	"github.com/programuoki/signflow/internal/db"
	"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)

	ctx := context.Background()

	// 1. Migrate. We use a throwaway database/sql handle (pgx stdlib driver)
	//    because goose speaks database/sql, then hand the app a pgx pool.
	if err := runMigrations(cfg.DatabaseURL, log); err != nil {
		return err
	}

	// 2. Connect the application pool the sqlc queries run against.
	pool, err := db.Connect(ctx, cfg.DatabaseURL)
	if err != nil {
		return err
	}
	defer pool.Close()

	queries := db.New(pool)
	h := handlers.New(cfg, queries, log)

	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(ctx, 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)
}

// runMigrations applies all pending goose migrations from the embedded FS.
func runMigrations(databaseURL string, log *slog.Logger) error {
	sqlDB, err := goose.OpenDBWithDriver("pgx", databaseURL)
	if err != nil {
		return err
	}
	defer sqlDB.Close()

	goose.SetBaseFS(migrations.FS)
	goose.SetLogger(gooseLogger{log})
	if err := goose.SetDialect("postgres"); err != nil {
		return err
	}
	return goose.Up(sqlDB, "migrations")
}

// gooseLogger adapts slog to goose's logger interface.
type gooseLogger struct{ log *slog.Logger }

func (g gooseLogger) Fatalf(format string, v ...interface{}) {
	g.log.Error("goose", "msg", fmt.Sprintf(format, v...))
}
func (g gooseLogger) Printf(format string, v ...interface{}) {
	g.log.Info("goose", "msg", fmt.Sprintf(format, v...))
}

// ensure the pgx stdlib driver is registered for goose.OpenDBWithDriver("pgx", ...)
var _ = stdlib.GetDefaultDriver

handlers.go MODIFIKUOTI 23 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/db"
	"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 a Queries field here
// (the database); sessions and more arrive in later lessons.
type Handlers struct {
	Cfg     config.Config
	Queries *db.Queries
	Log     *slog.Logger
}

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

// Home renders the landing page, including a live user count read from Postgres
// — proof the whole stack is wired end to end.
func (h *Handlers) Home(w http.ResponseWriter, r *http.Request) {
	count, err := h.Queries.CountUsers(r.Context())
	if err != nil {
		h.Log.Error("count users", "err", err)
		http.Error(w, "internal error", http.StatusInternalServerError)
		return
	}
	render(w, r, http.StatusOK, web.Home(count))
}

// Health is a liveness probe for Railway / uptime checks. It also pings the DB,
// so an unreachable database reports unhealthy rather than silently serving 500s.
func (h *Handlers) Health(w http.ResponseWriter, r *http.Request) {
	if _, err := h.Queries.CountUsers(r.Context()); err != nil {
		http.Error(w, "db unavailable", http.StatusServiceUnavailable)
		return
	}
	w.Header().Set("Content-Type", "text/plain")
	_, _ = w.Write([]byte("ok"))
}

home.templ MODIFIKUOTI 10 eilučių pakeista

Redaguok šį failą kataloge internal/web/

package web

import "strconv"

// Home is the public landing page. It also proves the full stack is wired: the
// user count comes from Postgres via sqlc.
templ Home(userCount int64) {
	@Layout("Home") {
		<section class="hero">
			<h1>Sign documents. Keep the receipts.</h1>
			<p class="lead">
				Upload a document, invite signers by email, and collect typed
				signatures. Every action lands in an append-only audit trail.
			</p>
			<div class="cta-row">
				<a class="btn btn-primary" href="/register">Get started</a>
				<a class="btn btn-ghost" href="/login">Log in</a>
			</div>
		</section>
		<section class="status-card">
			<h2>Skeleton status</h2>
			<ul class="checklist">
				<li>✅ Chi router + middleware</li>
				<li>✅ Templ rendering this page</li>
				<li>✅ Postgres connected via pgx</li>
				<li>✅ goose migrations applied</li>
			</ul>
			<p class="muted">
				Registered users in the database: <strong>{ strconv.FormatInt(userCount, 10) }</strong>
			</p>
		</section>
	}
}