Phase 0: bootstrap the Warp homeserver

Scaffolds the server module and everything Phase 0 of PLAN.md calls for:
a binary that boots, serves its discovery endpoints and nothing else yet.

- config: one YAML file plus per-field WARP_* environment overrides,
  unknown fields rejected, validation that reports every problem at once
- logging and metrics: slog, a Prometheus registry, per-route HTTP
  instrumentation labelled by pattern rather than path
- httputil: the Matrix error envelope, error-returning handlers, CORS,
  request logging, panic recovery, and a router over http.ServeMux
- endpoints: /_matrix/client/versions, /.well-known/matrix/client,
  /.well-known/matrix/server (gated), /healthz, /metrics, and
  M_UNRECOGNIZED for everything else
- storage: driver registry, shared database/sql base, checksummed
  migration runner, sqlite and postgres drivers, pocketbase stub
- settings: server_settings table behind a cached service, so the
  federation and registration switches change without a restart
- federation: the gate that makes federation a runtime mode
- cmd/warp: serve, migrate, generate-keys, version
- Makefile, golangci-lint v2, GitHub Actions CI (Linux and Windows tests,
  race on Linux, storage tests against PostgreSQL, lint, boot smoke test),
  Dockerfile, example config and docs

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

server/internal/storage/sqlstore/sqlstore.go

@@ -0,0 +1,124 @@
+// Package sqlstore holds the parts of a storage driver that are identical
+// for every database/sql backend: the migration plumbing and the
+// server_settings table. The sqlite and postgres drivers differ only in
+// their DSN handling, placeholder style and upsert syntax, all of which
+// they pass in here.
+package sqlstore
+
+import (
+	"context"
+	"database/sql"
+	"errors"
+	"fmt"
+	"io/fs"
+	"log/slog"
+
+	"github.com/dariuszjaniak/warp/server/internal/storage"
+	"github.com/dariuszjaniak/warp/server/internal/storage/migrations"
+)
+
+// Options describe one database/sql backend.
+type Options struct {
+	// DriverName is the Warp driver name, e.g. "sqlite".
+	DriverName string
+
+	// DB is the already-opened pool.
+	DB *sql.DB
+
+	// Dialect supplies the migration bookkeeping statements.
+	Dialect migrations.Dialect
+
+	// MigrationsFS and MigrationsDir locate the embedded .sql files.
+	MigrationsFS  fs.FS
+	MigrationsDir string
+
+	// Settings holds the statements for the server_settings table.
+	Settings SettingsQueries
+
+	// Logger is used for migration progress.
+	Logger *slog.Logger
+}
+
+// Store is the shared implementation of storage.Database. Drivers embed it
+// and add their own component stores as those are built.
+type Store struct {
+	opts     Options
+	db       *sql.DB
+	log      *slog.Logger
+	settings *Settings
+}
+
+// New builds a Store. It does not touch the database.
+func New(opts Options) (*Store, error) {
+	if opts.DB == nil {
+		return nil, errors.New("sqlstore: DB must not be nil")
+	}
+	if opts.Logger == nil {
+		opts.Logger = slog.Default()
+	}
+	return &Store{
+		opts:     opts,
+		db:       opts.DB,
+		log:      opts.Logger,
+		settings: NewSettings(opts.DB, opts.Settings),
+	}, nil
+}
+
+// DB exposes the pool for driver-specific code and tests.
+func (s *Store) DB() *sql.DB { return s.db }
+
+// Driver implements storage.Database.
+func (s *Store) Driver() string { return s.opts.DriverName }
+
+// Ping implements storage.Database.
+func (s *Store) Ping(ctx context.Context) error { return s.db.PingContext(ctx) }
+
+// Close implements storage.Database.
+func (s *Store) Close() error { return s.db.Close() }
+
+// Settings implements storage.Database.
+func (s *Store) Settings() storage.SettingsStore { return s.settings }
+
+// Migrate implements storage.Database.
+func (s *Store) Migrate(ctx context.Context) error {
+	ms, err := s.migrations()
+	if err != nil {
+		return err
+	}
+	applied, err := migrations.Status(ctx, s.db, s.opts.Dialect)
+	if err != nil {
+		return err
+	}
+	if err := migrations.CheckNotAhead(applied, ms); err != nil {
+		return err
+	}
+	n, err := migrations.Run(ctx, s.db, s.opts.Dialect, ms, s.log)
+	if err != nil {
+		return err
+	}
+	if n == 0 {
+		s.log.Debug("database schema is up to date", "migrations", len(ms))
+	}
+	return nil
+}
+
+// PendingMigrations implements storage.Database.
+func (s *Store) PendingMigrations(ctx context.Context) ([]string, error) {
+	ms, err := s.migrations()
+	if err != nil {
+		return nil, err
+	}
+	pending, err := migrations.Pending(ctx, s.db, s.opts.Dialect, ms)
+	if err != nil {
+		return nil, err
+	}
+	out := make([]string, 0, len(pending))
+	for _, m := range pending {
+		out = append(out, fmt.Sprintf("%04d_%s", m.Version, m.Name))
+	}
+	return out, nil
+}
+
+func (s *Store) migrations() ([]migrations.Migration, error) {
+	return migrations.Load(s.opts.MigrationsFS, s.opts.MigrationsDir)
+}