scrabble-game/backend/cmd/backend/main.go

// Command backend is the Scrabble platform's internal domain service. It boots
// the OpenTelemetry runtime, opens the Postgres pool and applies migrations,
// loads the dictionaries into the engine registry, warms the session cache,
// constructs the game domain and starts its turn-timeout sweeper, then serves the
// HTTP listener with the infrastructure probes and the /api/v1 route-group
// skeleton. Domain HTTP endpoints are added with the gateway in a later stage
// described in PLAN.md.
package main

import (
	"context"
	"fmt"
	"log"
	"os/signal"
	"syscall"
	"time"

	"go.uber.org/zap"

	"scrabble/backend/internal/account"
	"scrabble/backend/internal/config"
	"scrabble/backend/internal/engine"
	"scrabble/backend/internal/game"
	"scrabble/backend/internal/postgres"
	"scrabble/backend/internal/server"
	"scrabble/backend/internal/session"
	"scrabble/backend/internal/telemetry"
)

// telemetryShutdownTimeout bounds the OpenTelemetry flush during process exit.
const telemetryShutdownTimeout = 5 * time.Second

func main() {
	cfg, err := config.Load()
	if err != nil {
		log.Fatalf("backend: load config: %v", err)
	}

	logger, err := newLogger(cfg.LogLevel)
	if err != nil {
		log.Fatalf("backend: build logger: %v", err)
	}
	defer func() { _ = logger.Sync() }()

	ctx, stop := signal.NotifyContext(context.Background(), syscall.SIGINT, syscall.SIGTERM)
	defer stop()

	if err := run(ctx, cfg, logger); err != nil {
		logger.Fatal("backend: terminated", zap.Error(err))
	}
}

// run wires the process dependencies in order — telemetry, database (with
// migrations), engine dictionaries, session cache, game domain (with its
// turn-timeout sweeper), HTTP server — and blocks until ctx is cancelled.
func run(ctx context.Context, cfg config.Config, logger *zap.Logger) error {
	tel, err := telemetry.New(ctx, cfg.Telemetry)
	if err != nil {
		return fmt.Errorf("init telemetry: %w", err)
	}
	defer func() {
		shutdownCtx, cancel := context.WithTimeout(context.Background(), telemetryShutdownTimeout)
		defer cancel()
		if err := tel.Shutdown(shutdownCtx); err != nil {
			logger.Warn("telemetry shutdown", zap.Error(err))
		}
	}()

	db, err := postgres.Open(ctx, cfg.Postgres,
		postgres.WithTracerProvider(tel.TracerProvider()),
		postgres.WithMeterProvider(tel.MeterProvider()),
	)
	if err != nil {
		return fmt.Errorf("open database: %w", err)
	}
	defer func() { _ = db.Close() }()

	if err := postgres.ApplyMigrations(ctx, db); err != nil {
		return fmt.Errorf("apply migrations: %w", err)
	}
	logger.Info("database migrations applied")

	registry, err := engine.Open(cfg.Game.DictDir, cfg.Game.DictVersion)
	if err != nil {
		return fmt.Errorf("load dictionaries: %w", err)
	}
	defer func() { _ = registry.Close() }()
	logger.Info("dictionaries loaded",
		zap.String("dir", cfg.Game.DictDir),
		zap.String("version", cfg.Game.DictVersion))

	sessions := session.NewService(session.NewStore(db), session.NewCache())
	if err := sessions.Warm(ctx); err != nil {
		return fmt.Errorf("warm session cache: %w", err)
	}
	logger.Info("session cache warmed")

	games := game.NewService(game.NewStore(db), account.NewStore(db), registry, cfg.Game, logger)
	go games.RunSweeper(ctx, cfg.Game.TimeoutSweepInterval)
	logger.Info("game turn-timeout sweeper started",
		zap.Duration("interval", cfg.Game.TimeoutSweepInterval))

	srv := server.New(cfg.HTTPAddr, server.Deps{
		Logger:        logger,
		DB:            db,
		PingTimeout:   cfg.Postgres.OperationTimeout,
		SessionsReady: sessions.Ready,
	})
	return srv.Run(ctx)
}

// newLogger builds a production JSON logger at the given level.
func newLogger(level string) (*zap.Logger, error) {
	var lvl zap.AtomicLevel
	if err := lvl.UnmarshalText([]byte(level)); err != nil {
		return nil, err
	}
	cfg := zap.NewProductionConfig()
	cfg.Level = lvl
	return cfg.Build()
}