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,175 @@
+// Package listmygames implements the `lobby.my_games.list` message
+// type. It returns the games where the acting user holds an active
+// membership and the game status is `running` or `paused`, matching
+// `lobby/README.md` §«My active games». The denormalized runtime
+// snapshot already lives on the game record, so the response is
+// produced from `gameStore.Get` alone — no fan-out to Game Master.
+//
+// The service is exclusively self-service: admin actors are rejected
+// with `shared.ErrForbidden`, mirroring `listmyracenames`.
+package listmygames
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"log/slog"
+	"sort"
+	"time"
+
+	"galaxy/lobby/internal/domain/common"
+	"galaxy/lobby/internal/domain/game"
+	"galaxy/lobby/internal/domain/membership"
+	"galaxy/lobby/internal/ports"
+	"galaxy/lobby/internal/service/shared"
+)
+
+// activeGameStatuses lists the game statuses included in the user's
+// «active games» view per README §«My active games».
+var activeGameStatuses = map[game.Status]struct{}{
+	game.StatusRunning: {},
+	game.StatusPaused:  {},
+}
+
+// Service executes the list-my-games use case.
+type Service struct {
+	games       ports.GameStore
+	memberships ports.MembershipStore
+	logger      *slog.Logger
+}
+
+// Dependencies groups the collaborators used by Service.
+type Dependencies struct {
+	// Games is loaded per active membership to read game name, owner,
+	// status, and the denormalized runtime snapshot.
+	Games ports.GameStore
+
+	// Memberships supplies the per-user membership index.
+	Memberships ports.MembershipStore
+
+	// Logger records structured diagnostics. Defaults to slog.Default
+	// when nil.
+	Logger *slog.Logger
+}
+
+// NewService constructs one Service with deps.
+func NewService(deps Dependencies) (*Service, error) {
+	switch {
+	case deps.Games == nil:
+		return nil, errors.New("new list my games service: nil game store")
+	case deps.Memberships == nil:
+		return nil, errors.New("new list my games service: nil membership store")
+	}
+	logger := deps.Logger
+	if logger == nil {
+		logger = slog.Default()
+	}
+	return &Service{
+		games:       deps.Games,
+		memberships: deps.Memberships,
+		logger:      logger.With("service", "lobby.listmygames"),
+	}, nil
+}
+
+// Input stores the arguments required to compute the acting user's
+// active-games view.
+type Input struct {
+	// Actor identifies the caller. Must be ActorKindUser.
+	Actor shared.Actor
+
+	// Page stores the pagination request.
+	Page shared.Page
+}
+
+// Output stores the page returned by Handle.
+type Output struct {
+	// Items stores the active game records included in the current page.
+	Items []game.Game
+
+	// NextPageToken stores the opaque continuation token; empty when
+	// the current page is the last one.
+	NextPageToken string
+}
+
+// Handle authorizes the actor as a user, fetches their active
+// memberships, joins them with the game records, filters by status,
+// sorts deterministically, and returns the requested page.
+func (service *Service) Handle(ctx context.Context, input Input) (Output, error) {
+	if service == nil {
+		return Output{}, errors.New("list my games: nil service")
+	}
+	if ctx == nil {
+		return Output{}, errors.New("list my games: nil context")
+	}
+	if err := input.Actor.Validate(); err != nil {
+		return Output{}, fmt.Errorf("list my games: actor: %w", err)
+	}
+	if !input.Actor.IsUser() {
+		return Output{}, fmt.Errorf(
+			"%w: only authenticated user actors may list their games",
+			shared.ErrForbidden,
+		)
+	}
+
+	memberships, err := service.memberships.GetByUser(ctx, input.Actor.UserID)
+	if err != nil {
+		return Output{}, fmt.Errorf("list my games: %w", err)
+	}
+
+	seen := make(map[common.GameID]struct{})
+	candidates := make([]game.Game, 0, len(memberships))
+	for _, mb := range memberships {
+		if mb.Status != membership.StatusActive {
+			continue
+		}
+		if _, dup := seen[mb.GameID]; dup {
+			continue
+		}
+		record, err := service.games.Get(ctx, mb.GameID)
+		if err != nil {
+			if errors.Is(err, game.ErrNotFound) {
+				service.logger.WarnContext(ctx, "membership references missing game",
+					"user_id", input.Actor.UserID,
+					"game_id", mb.GameID.String(),
+				)
+				continue
+			}
+			return Output{}, fmt.Errorf("list my games: %w", err)
+		}
+		if _, ok := activeGameStatuses[record.Status]; !ok {
+			continue
+		}
+		seen[record.GameID] = struct{}{}
+		candidates = append(candidates, record)
+	}
+
+	sortRecords(candidates)
+
+	start, end, nextOffset, hasMore := shared.Window(len(candidates), input.Page)
+	out := Output{Items: append([]game.Game(nil), candidates[start:end]...)}
+	if hasMore {
+		out.NextPageToken = shared.EncodeToken(nextOffset)
+	}
+	return out, nil
+}
+
+// sortRecords orders items by StartedAt descending so the most recently
+// started games surface first. Records without StartedAt fall back to
+// CreatedAt; GameID breaks ties for stable output.
+func sortRecords(items []game.Game) {
+	sort.Slice(items, func(i, j int) bool {
+		ti := startedOrCreated(items[i])
+		tj := startedOrCreated(items[j])
+		if !ti.Equal(tj) {
+			return ti.After(tj)
+		}
+		return items[i].GameID < items[j].GameID
+	})
+}
+
+func startedOrCreated(record game.Game) time.Time {
+	if record.StartedAt != nil {
+		return *record.StartedAt
+	}
+	return record.CreatedAt
+}
@@ -0,0 +1,201 @@
+package listmygames_test
+
+import (
+	"context"
+	"io"
+	"log/slog"
+	"testing"
+	"time"
+
+	"galaxy/lobby/internal/adapters/gamestub"
+	"galaxy/lobby/internal/adapters/membershipstub"
+	"galaxy/lobby/internal/domain/common"
+	"galaxy/lobby/internal/domain/game"
+	"galaxy/lobby/internal/domain/membership"
+	"galaxy/lobby/internal/ports"
+	"galaxy/lobby/internal/service/listmygames"
+	"galaxy/lobby/internal/service/shared"
+
+	"github.com/stretchr/testify/require"
+)
+
+func silentLogger() *slog.Logger {
+	return slog.New(slog.NewTextHandler(io.Discard, nil))
+}
+
+type fixture struct {
+	games       *gamestub.Store
+	memberships *membershipstub.Store
+	svc         *listmygames.Service
+}
+
+func newFixture(t *testing.T) *fixture {
+	t.Helper()
+	games := gamestub.NewStore()
+	memberships := membershipstub.NewStore()
+	svc, err := listmygames.NewService(listmygames.Dependencies{
+		Games:       games,
+		Memberships: memberships,
+		Logger:      silentLogger(),
+	})
+	require.NoError(t, err)
+	return &fixture{games: games, memberships: memberships, svc: svc}
+}
+
+func seedGameWithStatus(
+	t *testing.T,
+	store *gamestub.Store,
+	id common.GameID,
+	status game.Status,
+	now time.Time,
+) {
+	t.Helper()
+	record, err := game.New(game.NewGameInput{
+		GameID:              id,
+		GameName:            "Seed",
+		GameType:            game.GameTypePublic,
+		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)
+	if status != game.StatusDraft {
+		record.Status = status
+		record.UpdatedAt = now.Add(time.Minute)
+		if status == game.StatusRunning || status == game.StatusPaused ||
+			status == game.StatusFinished {
+			started := now.Add(time.Minute)
+			record.StartedAt = &started
+		}
+	}
+	require.NoError(t, store.Save(context.Background(), record))
+}
+
+func seedMembership(
+	t *testing.T,
+	store *membershipstub.Store,
+	gameID common.GameID,
+	userID string,
+	status membership.Status,
+	joinedAt time.Time,
+) {
+	t.Helper()
+	record, err := membership.New(membership.NewMembershipInput{
+		MembershipID: common.MembershipID("membership-" + userID + "-" + gameID.String()),
+		GameID:       gameID,
+		UserID:       userID,
+		RaceName:     "Race-" + userID,
+		CanonicalKey: "race-" + userID,
+		Now:          joinedAt,
+	})
+	require.NoError(t, err)
+	require.NoError(t, store.Save(context.Background(), record))
+	if status != membership.StatusActive {
+		require.NoError(t, store.UpdateStatus(context.Background(), ports.UpdateMembershipStatusInput{
+			MembershipID: record.MembershipID,
+			ExpectedFrom: membership.StatusActive,
+			To:           status,
+			At:           joinedAt.Add(time.Minute),
+		}))
+	}
+}
+
+func TestHandleReturnsRunningAndPaused(t *testing.T) {
+	t.Parallel()
+	fix := newFixture(t)
+	now := time.Date(2025, 6, 1, 12, 0, 0, 0, time.UTC)
+
+	seedGameWithStatus(t, fix.games, "game-running", game.StatusRunning, now)
+	seedGameWithStatus(t, fix.games, "game-paused", game.StatusPaused, now)
+	seedGameWithStatus(t, fix.games, "game-finished", game.StatusFinished, now)
+	seedGameWithStatus(t, fix.games, "game-enroll", game.StatusEnrollmentOpen, now)
+	for _, id := range []common.GameID{"game-running", "game-paused", "game-finished", "game-enroll"} {
+		seedMembership(t, fix.memberships, id, "user-1", membership.StatusActive, now)
+	}
+
+	out, err := fix.svc.Handle(context.Background(), listmygames.Input{
+		Actor: shared.NewUserActor("user-1"),
+	})
+	require.NoError(t, err)
+	require.Len(t, out.Items, 2)
+	gotIDs := []common.GameID{out.Items[0].GameID, out.Items[1].GameID}
+	require.Contains(t, gotIDs, common.GameID("game-running"))
+	require.Contains(t, gotIDs, common.GameID("game-paused"))
+}
+
+func TestHandleIgnoresRemovedAndBlockedMemberships(t *testing.T) {
+	t.Parallel()
+	fix := newFixture(t)
+	now := time.Date(2025, 6, 1, 12, 0, 0, 0, time.UTC)
+
+	seedGameWithStatus(t, fix.games, "game-removed", game.StatusRunning, now)
+	seedGameWithStatus(t, fix.games, "game-blocked", game.StatusRunning, now)
+	seedGameWithStatus(t, fix.games, "game-active", game.StatusRunning, now)
+	seedMembership(t, fix.memberships, "game-removed", "user-1", membership.StatusRemoved, now)
+	seedMembership(t, fix.memberships, "game-blocked", "user-1", membership.StatusBlocked, now)
+	seedMembership(t, fix.memberships, "game-active", "user-1", membership.StatusActive, now)
+
+	out, err := fix.svc.Handle(context.Background(), listmygames.Input{
+		Actor: shared.NewUserActor("user-1"),
+	})
+	require.NoError(t, err)
+	require.Len(t, out.Items, 1)
+	require.Equal(t, common.GameID("game-active"), out.Items[0].GameID)
+}
+
+func TestHandleAdminForbidden(t *testing.T) {
+	t.Parallel()
+	fix := newFixture(t)
+
+	_, err := fix.svc.Handle(context.Background(), listmygames.Input{
+		Actor: shared.NewAdminActor(),
+	})
+	require.ErrorIs(t, err, shared.ErrForbidden)
+}
+
+func TestHandlePaginationAndOrder(t *testing.T) {
+	t.Parallel()
+	fix := newFixture(t)
+	now := time.Date(2025, 6, 1, 12, 0, 0, 0, time.UTC)
+
+	for i := range 4 {
+		id := common.GameID("game-page-" + string(rune('a'+i)))
+		seedGameWithStatus(t, fix.games, id, game.StatusRunning, now.Add(time.Duration(i)*time.Minute))
+		seedMembership(t, fix.memberships, id, "user-1", membership.StatusActive, now)
+	}
+
+	out, err := fix.svc.Handle(context.Background(), listmygames.Input{
+		Actor: shared.NewUserActor("user-1"),
+		Page:  shared.Page{Size: 2},
+	})
+	require.NoError(t, err)
+	require.Len(t, out.Items, 2)
+	require.NotEmpty(t, out.NextPageToken)
+
+	// Most recently started first.
+	require.Equal(t, common.GameID("game-page-d"), out.Items[0].GameID)
+	require.Equal(t, common.GameID("game-page-c"), out.Items[1].GameID)
+}
+
+func TestNewServiceRejectsMissingDeps(t *testing.T) {
+	t.Parallel()
+	cases := []struct {
+		name string
+		deps listmygames.Dependencies
+	}{
+		{"nil games", listmygames.Dependencies{Memberships: membershipstub.NewStore()}},
+		{"nil memberships", listmygames.Dependencies{Games: gamestub.NewStore()}},
+	}
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			t.Parallel()
+			_, err := listmygames.NewService(tc.deps)
+			require.Error(t, err)
+		})
+	}
+}