feat: game lobby service

2026-04-25 23:20:55 +02:00
parent 32dc29359a
commit 48b0056b49
336 changed files with 57074 additions and 1418 deletions
@@ -0,0 +1,235 @@
+// Package updategame implements the `lobby.game.update` message type. It
+// applies partial edits to a game record under the following rules:
+//
+//   - in status `draft`: any field from the request schema is mutable;
+//   - in status `enrollment_open`: only `description` is mutable;
+//   - in every other status: no field is mutable and the call returns
+//     game.ErrConflict.
+//
+// Authorization is admin OR (user + private game + matching OwnerUserID).
+// Non-owners receive shared.ErrForbidden.
+package updategame
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"log/slog"
+	"time"
+
+	"galaxy/lobby/internal/domain/common"
+	"galaxy/lobby/internal/domain/game"
+	"galaxy/lobby/internal/ports"
+	"galaxy/lobby/internal/service/shared"
+)
+
+// Service executes the update-game use case.
+type Service struct {
+	games  ports.GameStore
+	clock  func() time.Time
+	logger *slog.Logger
+}
+
+// Dependencies groups the collaborators used by Service.
+type Dependencies struct {
+	// Games persists the updated record.
+	Games ports.GameStore
+
+	// Clock supplies the wall-clock used for UpdatedAt. Defaults to
+	// time.Now when nil.
+	Clock func() time.Time
+
+	// Logger records structured service-level events. Defaults to
+	// slog.Default when nil.
+	Logger *slog.Logger
+}
+
+// NewService constructs one Service with deps.
+func NewService(deps Dependencies) (*Service, error) {
+	if deps.Games == nil {
+		return nil, errors.New("new update game service: nil game store")
+	}
+
+	clock := deps.Clock
+	if clock == nil {
+		clock = time.Now
+	}
+	logger := deps.Logger
+	if logger == nil {
+		logger = slog.Default()
+	}
+
+	return &Service{
+		games:  deps.Games,
+		clock:  clock,
+		logger: logger.With("service", "lobby.updategame"),
+	}, nil
+}
+
+// Input stores the arguments required to update one game record. Every
+// mutable field is represented by a pointer so callers can distinguish
+// "absent" from the zero value.
+type Input struct {
+	// Actor identifies the caller.
+	Actor shared.Actor
+
+	// GameID identifies the record to update.
+	GameID common.GameID
+
+	// GameName updates the human-readable game name when non-nil.
+	GameName *string
+
+	// Description updates the human-readable description when non-nil.
+	Description *string
+
+	// MinPlayers updates the minimum approved participant count when
+	// non-nil.
+	MinPlayers *int
+
+	// MaxPlayers updates the target roster size when non-nil.
+	MaxPlayers *int
+
+	// StartGapHours updates the gap window length in hours when non-nil.
+	StartGapHours *int
+
+	// StartGapPlayers updates the gap window additional participant count
+	// when non-nil.
+	StartGapPlayers *int
+
+	// EnrollmentEndsAt updates the enrollment deadline when non-nil.
+	EnrollmentEndsAt *time.Time
+
+	// TurnSchedule updates the cron expression when non-nil.
+	TurnSchedule *string
+
+	// TargetEngineVersion updates the engine semver when non-nil.
+	TargetEngineVersion *string
+}
+
+// HasNonDescriptionFields reports whether input carries any mutation other
+// than Description.
+func (input Input) HasNonDescriptionFields() bool {
+	return input.GameName != nil ||
+		input.MinPlayers != nil ||
+		input.MaxPlayers != nil ||
+		input.StartGapHours != nil ||
+		input.StartGapPlayers != nil ||
+		input.EnrollmentEndsAt != nil ||
+		input.TurnSchedule != nil ||
+		input.TargetEngineVersion != nil
+}
+
+// Handle validates, authorizes, and applies the partial update. It returns
+// the persisted record on success.
+func (service *Service) Handle(ctx context.Context, input Input) (game.Game, error) {
+	if service == nil {
+		return game.Game{}, errors.New("update game: nil service")
+	}
+	if ctx == nil {
+		return game.Game{}, errors.New("update game: nil context")
+	}
+	if err := input.Actor.Validate(); err != nil {
+		return game.Game{}, fmt.Errorf("update game: actor: %w", err)
+	}
+	if err := input.GameID.Validate(); err != nil {
+		return game.Game{}, fmt.Errorf("update game: %w", err)
+	}
+
+	record, err := service.games.Get(ctx, input.GameID)
+	if err != nil {
+		return game.Game{}, fmt.Errorf("update game: %w", err)
+	}
+
+	if err := authorize(input.Actor, record); err != nil {
+		return game.Game{}, err
+	}
+
+	if err := enforceStatusGate(record.Status, input); err != nil {
+		return game.Game{}, err
+	}
+
+	applyPatch(&record, input, service.clock().UTC())
+
+	if err := record.Validate(); err != nil {
+		return game.Game{}, fmt.Errorf("update game: %w", err)
+	}
+
+	if err := service.games.Save(ctx, record); err != nil {
+		return game.Game{}, fmt.Errorf("update game: %w", err)
+	}
+
+	service.logger.InfoContext(ctx, "game updated",
+		"game_id", record.GameID.String(),
+		"status", string(record.Status),
+		"actor_kind", string(input.Actor.Kind),
+	)
+
+	return record, nil
+}
+
+// authorize enforces admin OR private-owner access to the record.
+func authorize(actor shared.Actor, record game.Game) error {
+	if actor.IsAdmin() {
+		return nil
+	}
+	if record.GameType == game.GameTypePrivate && actor.UserID == record.OwnerUserID {
+		return nil
+	}
+	return fmt.Errorf("%w: actor is not authorized to update game %q",
+		shared.ErrForbidden, record.GameID.String())
+}
+
+// enforceStatusGate returns game.ErrConflict when the request attempts a
+// field mutation disallowed by the current status.
+func enforceStatusGate(status game.Status, input Input) error {
+	switch status {
+	case game.StatusDraft:
+		return nil
+	case game.StatusEnrollmentOpen:
+		if input.HasNonDescriptionFields() {
+			return fmt.Errorf(
+				"update game: only description is editable in status %q: %w",
+				status, game.ErrConflict,
+			)
+		}
+		return nil
+	default:
+		return fmt.Errorf(
+			"update game: status %q does not accept field updates: %w",
+			status, game.ErrConflict,
+		)
+	}
+}
+
+// applyPatch overwrites non-nil fields from input onto record. Callers must
+// re-validate the result before persisting.
+func applyPatch(record *game.Game, input Input, now time.Time) {
+	if input.GameName != nil {
+		record.GameName = *input.GameName
+	}
+	if input.Description != nil {
+		record.Description = *input.Description
+	}
+	if input.MinPlayers != nil {
+		record.MinPlayers = *input.MinPlayers
+	}
+	if input.MaxPlayers != nil {
+		record.MaxPlayers = *input.MaxPlayers
+	}
+	if input.StartGapHours != nil {
+		record.StartGapHours = *input.StartGapHours
+	}
+	if input.StartGapPlayers != nil {
+		record.StartGapPlayers = *input.StartGapPlayers
+	}
+	if input.EnrollmentEndsAt != nil {
+		record.EnrollmentEndsAt = input.EnrollmentEndsAt.UTC()
+	}
+	if input.TurnSchedule != nil {
+		record.TurnSchedule = *input.TurnSchedule
+	}
+	if input.TargetEngineVersion != nil {
+		record.TargetEngineVersion = *input.TargetEngineVersion
+	}
+	record.UpdatedAt = now
+}
@@ -0,0 +1,307 @@
+package updategame_test
+
+import (
+	"context"
+	"io"
+	"log/slog"
+	"testing"
+	"time"
+
+	"galaxy/lobby/internal/adapters/gamestub"
+	"galaxy/lobby/internal/domain/common"
+	"galaxy/lobby/internal/domain/game"
+	"galaxy/lobby/internal/ports"
+	"galaxy/lobby/internal/service/shared"
+	"galaxy/lobby/internal/service/updategame"
+
+	"github.com/stretchr/testify/require"
+)
+
+func silentLogger() *slog.Logger {
+	return slog.New(slog.NewTextHandler(io.Discard, nil))
+}
+
+func fixedClock(at time.Time) func() time.Time {
+	return func() time.Time { return at }
+}
+
+// seedDraftGame stores a draft record with sensible defaults for tests and
+// returns the persisted record.
+func seedDraftGame(
+	t *testing.T,
+	store *gamestub.Store,
+	id common.GameID,
+	gameType game.GameType,
+	ownerUserID string,
+	now time.Time,
+) game.Game {
+	t.Helper()
+
+	record, err := game.New(game.NewGameInput{
+		GameID:              id,
+		GameName:            "Seed Game",
+		GameType:            gameType,
+		OwnerUserID:         ownerUserID,
+		MinPlayers:          2,
+		MaxPlayers:          4,
+		StartGapHours:       4,
+		StartGapPlayers:     1,
+		EnrollmentEndsAt:    now.Add(24 * time.Hour),
+		TurnSchedule:        "0 */6 * * *",
+		TargetEngineVersion: "1.0.0",
+		Now:                 now,
+	})
+	require.NoError(t, err)
+	require.NoError(t, store.Save(context.Background(), record))
+
+	return record
+}
+
+func newService(t *testing.T, store ports.GameStore, clock func() time.Time) *updategame.Service {
+	t.Helper()
+
+	svc, err := updategame.NewService(updategame.Dependencies{
+		Games:  store,
+		Clock:  clock,
+		Logger: silentLogger(),
+	})
+	require.NoError(t, err)
+	return svc
+}
+
+func TestHandleAdminFullEditInDraft(t *testing.T) {
+	t.Parallel()
+
+	now := time.Date(2026, 4, 24, 10, 0, 0, 0, time.UTC)
+	store := gamestub.NewStore()
+	seedDraftGame(t, store, "game-a", game.GameTypePublic, "", now)
+
+	later := now.Add(30 * time.Minute)
+	service := newService(t, store, fixedClock(later))
+
+	updated, err := service.Handle(context.Background(), updategame.Input{
+		Actor:               shared.NewAdminActor(),
+		GameID:              "game-a",
+		GameName:            new("Spring Cup"),
+		Description:         new("Warm-up round"),
+		MinPlayers:          new(3),
+		MaxPlayers:          new(6),
+		StartGapHours:       new(2),
+		StartGapPlayers:     new(2),
+		TurnSchedule:        new("0 9 * * *"),
+		TargetEngineVersion: new("1.1.0"),
+	})
+	require.NoError(t, err)
+	require.Equal(t, "Spring Cup", updated.GameName)
+	require.Equal(t, "Warm-up round", updated.Description)
+	require.Equal(t, 3, updated.MinPlayers)
+	require.Equal(t, 6, updated.MaxPlayers)
+	require.Equal(t, 2, updated.StartGapHours)
+	require.Equal(t, 2, updated.StartGapPlayers)
+	require.Equal(t, "0 9 * * *", updated.TurnSchedule)
+	require.Equal(t, "1.1.0", updated.TargetEngineVersion)
+	require.Equal(t, later.UTC(), updated.UpdatedAt)
+}
+
+func TestHandleOwnerEditInDraft(t *testing.T) {
+	t.Parallel()
+
+	now := time.Date(2026, 4, 24, 10, 0, 0, 0, time.UTC)
+	store := gamestub.NewStore()
+	seedDraftGame(t, store, "game-private", game.GameTypePrivate, "user-1", now)
+
+	service := newService(t, store, fixedClock(now.Add(time.Hour)))
+
+	updated, err := service.Handle(context.Background(), updategame.Input{
+		Actor:       shared.NewUserActor("user-1"),
+		GameID:      "game-private",
+		Description: new("Private scrim"),
+	})
+	require.NoError(t, err)
+	require.Equal(t, "Private scrim", updated.Description)
+}
+
+func TestHandleNonOwnerForbidden(t *testing.T) {
+	t.Parallel()
+
+	now := time.Date(2026, 4, 24, 10, 0, 0, 0, time.UTC)
+	store := gamestub.NewStore()
+	seedDraftGame(t, store, "game-private", game.GameTypePrivate, "user-1", now)
+
+	service := newService(t, store, fixedClock(now.Add(time.Hour)))
+
+	_, err := service.Handle(context.Background(), updategame.Input{
+		Actor:       shared.NewUserActor("user-2"),
+		GameID:      "game-private",
+		Description: new("drive-by"),
+	})
+	require.ErrorIs(t, err, shared.ErrForbidden)
+}
+
+func TestHandleUserCannotEditPublicGame(t *testing.T) {
+	t.Parallel()
+
+	now := time.Date(2026, 4, 24, 10, 0, 0, 0, time.UTC)
+	store := gamestub.NewStore()
+	seedDraftGame(t, store, "game-public", game.GameTypePublic, "", now)
+
+	service := newService(t, store, fixedClock(now.Add(time.Hour)))
+
+	_, err := service.Handle(context.Background(), updategame.Input{
+		Actor:       shared.NewUserActor("user-1"),
+		GameID:      "game-public",
+		Description: new("drive-by"),
+	})
+	require.ErrorIs(t, err, shared.ErrForbidden)
+}
+
+func TestHandleEnrollmentOpenDescriptionOnly(t *testing.T) {
+	t.Parallel()
+
+	now := time.Date(2026, 4, 24, 10, 0, 0, 0, time.UTC)
+	store := gamestub.NewStore()
+	record := seedDraftGame(t, store, "game-open", game.GameTypePublic, "", now)
+
+	// Force status to enrollment_open via UpdateStatus.
+	require.NoError(t, store.UpdateStatus(context.Background(), ports.UpdateStatusInput{
+		GameID:       record.GameID,
+		ExpectedFrom: game.StatusDraft,
+		To:           game.StatusEnrollmentOpen,
+		Trigger:      game.TriggerCommand,
+		At:           now.Add(5 * time.Minute),
+	}))
+
+	service := newService(t, store, fixedClock(now.Add(time.Hour)))
+
+	updated, err := service.Handle(context.Background(), updategame.Input{
+		Actor:       shared.NewAdminActor(),
+		GameID:      record.GameID,
+		Description: new("Updated while enrollment is open"),
+	})
+	require.NoError(t, err)
+	require.Equal(t, "Updated while enrollment is open", updated.Description)
+	require.Equal(t, game.StatusEnrollmentOpen, updated.Status)
+}
+
+func TestHandleEnrollmentOpenNonDescriptionRejected(t *testing.T) {
+	t.Parallel()
+
+	now := time.Date(2026, 4, 24, 10, 0, 0, 0, time.UTC)
+	store := gamestub.NewStore()
+	record := seedDraftGame(t, store, "game-open", game.GameTypePublic, "", now)
+
+	require.NoError(t, store.UpdateStatus(context.Background(), ports.UpdateStatusInput{
+		GameID:       record.GameID,
+		ExpectedFrom: game.StatusDraft,
+		To:           game.StatusEnrollmentOpen,
+		Trigger:      game.TriggerCommand,
+		At:           now.Add(5 * time.Minute),
+	}))
+
+	service := newService(t, store, fixedClock(now.Add(time.Hour)))
+
+	_, err := service.Handle(context.Background(), updategame.Input{
+		Actor:      shared.NewAdminActor(),
+		GameID:     record.GameID,
+		MinPlayers: new(5),
+	})
+	require.ErrorIs(t, err, game.ErrConflict)
+}
+
+func TestHandleTerminalStatusRejected(t *testing.T) {
+	t.Parallel()
+
+	now := time.Date(2026, 4, 24, 10, 0, 0, 0, time.UTC)
+	store := gamestub.NewStore()
+	record := seedDraftGame(t, store, "game-cancel", game.GameTypePublic, "", now)
+
+	require.NoError(t, store.UpdateStatus(context.Background(), ports.UpdateStatusInput{
+		GameID:       record.GameID,
+		ExpectedFrom: game.StatusDraft,
+		To:           game.StatusCancelled,
+		Trigger:      game.TriggerCommand,
+		At:           now.Add(10 * time.Minute),
+	}))
+
+	service := newService(t, store, fixedClock(now.Add(time.Hour)))
+
+	_, err := service.Handle(context.Background(), updategame.Input{
+		Actor:       shared.NewAdminActor(),
+		GameID:      record.GameID,
+		Description: new("ignored"),
+	})
+	require.ErrorIs(t, err, game.ErrConflict)
+}
+
+func TestHandleNotFound(t *testing.T) {
+	t.Parallel()
+
+	store := gamestub.NewStore()
+	service := newService(t, store, fixedClock(time.Date(2026, 4, 24, 10, 0, 0, 0, time.UTC)))
+
+	_, err := service.Handle(context.Background(), updategame.Input{
+		Actor:       shared.NewAdminActor(),
+		GameID:      "game-missing",
+		Description: new("nope"),
+	})
+	require.ErrorIs(t, err, game.ErrNotFound)
+}
+
+func TestHandleValidationFailurePropagates(t *testing.T) {
+	t.Parallel()
+
+	now := time.Date(2026, 4, 24, 10, 0, 0, 0, time.UTC)
+	store := gamestub.NewStore()
+	seedDraftGame(t, store, "game-a", game.GameTypePublic, "", now)
+
+	service := newService(t, store, fixedClock(now.Add(time.Hour)))
+
+	_, err := service.Handle(context.Background(), updategame.Input{
+		Actor:      shared.NewAdminActor(),
+		GameID:     "game-a",
+		MinPlayers: new(10),
+		MaxPlayers: new(5),
+	})
+	require.Error(t, err)
+	require.Contains(t, err.Error(), "max players")
+}
+
+func TestHandleInvalidActorReturnsError(t *testing.T) {
+	t.Parallel()
+
+	now := time.Date(2026, 4, 24, 10, 0, 0, 0, time.UTC)
+	store := gamestub.NewStore()
+	service := newService(t, store, fixedClock(now))
+
+	_, err := service.Handle(context.Background(), updategame.Input{
+		Actor:       shared.Actor{Kind: shared.ActorKindUser}, // missing user id
+		GameID:      "game-a",
+		Description: new("x"),
+	})
+	require.Error(t, err)
+	require.Contains(t, err.Error(), "actor")
+}
+
+func TestHandleInvalidGameID(t *testing.T) {
+	t.Parallel()
+
+	now := time.Date(2026, 4, 24, 10, 0, 0, 0, time.UTC)
+	store := gamestub.NewStore()
+	service := newService(t, store, fixedClock(now))
+
+	_, err := service.Handle(context.Background(), updategame.Input{
+		Actor:       shared.NewAdminActor(),
+		GameID:      "bad",
+		Description: new("x"),
+	})
+	require.Error(t, err)
+}
+
+func TestInputHasNonDescriptionFields(t *testing.T) {
+	t.Parallel()
+
+	require.False(t, updategame.Input{}.HasNonDescriptionFields())
+	require.False(t, updategame.Input{Description: new("x")}.HasNonDescriptionFields())
+	require.True(t, updategame.Input{GameName: new("x")}.HasNonDescriptionFields())
+	require.True(t, updategame.Input{MinPlayers: new(1)}.HasNonDescriptionFields())
+}