Ilia Denisov
f57a290432
- Extend pkg/model/lobby and pkg/schema/fbs/lobby.fbs with public-games
list, my-applications/invites lists, game-create, application-submit,
invite-redeem/decline. Mirror the matching transcoder pairs and Go
fixture round-trip tests.
- Wire the seven new lobby message types through
gateway/internal/backendclient/{routes,lobby_commands}.go with
per-command REST helpers, JSON-tolerant decoding of backend wire
shapes, and httptest-based unit coverage for success / 4xx / 5xx /
503 across each command.
- Introduce TS-side FlatBuffers via the `flatbuffers` runtime dep, a
`make fbs-ts` target driving flatc, and the generated bindings under
ui/frontend/src/proto/galaxy/fbs. Phase 7's `user.account.get` decode
now uses these bindings as well, closing the JSON.parse vs
FlatBuffers gap that would have failed against a real local stack.
- Replace the placeholder lobby with five sections (my games, pending
invitations, my applications, public games, create new game) and the
/lobby/create form. Submit-application uses an inline race-name
form on the public-game card; create-game keeps name / description /
turn_schedule / enrollment_ends_at always visible and the rest under
an Advanced toggle with TS-side defaults.
- Update lobby/+page.svelte to throw LobbyError on non-ok result codes;
GalaxyClient.executeCommand now returns { resultCode, payloadBytes }.
- Vitest binding round-trips, lobby.ts wrapper unit tests, lobby-page
+ lobby-create component tests, Playwright lobby-flow.spec covering
create / submit / accept across all four projects. Phase 7 e2e was
migrated to the FlatBuffers fixtures and to click+fill against the
Safari-autofill readonly inputs.
- Mark Phase 8 done in ui/PLAN.md, mirror the wire-format note into
Phase 7, append the new lobby commands to gateway/README.md and
docs/ARCHITECTURE.md, add ui/docs/lobby.md.
Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
105 lines
3.5 KiB
Go
105 lines
3.5 KiB
Go
package backendclient
|
|
|
|
import (
|
|
"context"
|
|
|
|
"galaxy/gateway/internal/downstream"
|
|
lobbymodel "galaxy/model/lobby"
|
|
ordermodel "galaxy/model/order"
|
|
reportmodel "galaxy/model/report"
|
|
usermodel "galaxy/model/user"
|
|
)
|
|
|
|
// UserRoutes returns the authenticated `user.*` downstream routes
|
|
// served by backend. When client is nil every route resolves to a
|
|
// dependency-unavailable client so the static router still recognises
|
|
// the message types.
|
|
func UserRoutes(client *RESTClient) map[string]downstream.Client {
|
|
target := downstream.Client(unavailableClient{})
|
|
if client != nil {
|
|
target = userCommandClient{rest: client}
|
|
}
|
|
return map[string]downstream.Client{
|
|
usermodel.MessageTypeGetMyAccount: target,
|
|
usermodel.MessageTypeUpdateMyProfile: target,
|
|
usermodel.MessageTypeUpdateMySettings: target,
|
|
usermodel.MessageTypeListMySessions: target,
|
|
usermodel.MessageTypeRevokeMySession: target,
|
|
usermodel.MessageTypeRevokeAllMySessions: target,
|
|
}
|
|
}
|
|
|
|
// LobbyRoutes returns the authenticated `lobby.*` downstream routes
|
|
// served by backend. When client is nil every route resolves to a
|
|
// dependency-unavailable client.
|
|
func LobbyRoutes(client *RESTClient) map[string]downstream.Client {
|
|
target := downstream.Client(unavailableClient{})
|
|
if client != nil {
|
|
target = lobbyCommandClient{rest: client}
|
|
}
|
|
return map[string]downstream.Client{
|
|
lobbymodel.MessageTypeMyGamesList: target,
|
|
lobbymodel.MessageTypePublicGamesList: target,
|
|
lobbymodel.MessageTypeMyApplicationsList: target,
|
|
lobbymodel.MessageTypeMyInvitesList: target,
|
|
lobbymodel.MessageTypeOpenEnrollment: target,
|
|
lobbymodel.MessageTypeGameCreate: target,
|
|
lobbymodel.MessageTypeApplicationSubmit: target,
|
|
lobbymodel.MessageTypeInviteRedeem: target,
|
|
lobbymodel.MessageTypeInviteDecline: target,
|
|
}
|
|
}
|
|
|
|
// GameRoutes returns the authenticated `user.games.*` downstream
|
|
// routes served by backend (which in turn forwards to the running
|
|
// game engine container). When client is nil every route resolves to
|
|
// a dependency-unavailable client.
|
|
func GameRoutes(client *RESTClient) map[string]downstream.Client {
|
|
target := downstream.Client(unavailableClient{})
|
|
if client != nil {
|
|
target = gameCommandClient{rest: client}
|
|
}
|
|
return map[string]downstream.Client{
|
|
ordermodel.MessageTypeUserGamesCommand: target,
|
|
ordermodel.MessageTypeUserGamesOrder: target,
|
|
reportmodel.MessageTypeUserGamesReport: target,
|
|
}
|
|
}
|
|
|
|
type unavailableClient struct{}
|
|
|
|
func (unavailableClient) ExecuteCommand(context.Context, downstream.AuthenticatedCommand) (downstream.UnaryResult, error) {
|
|
return downstream.UnaryResult{}, downstream.ErrDownstreamUnavailable
|
|
}
|
|
|
|
type userCommandClient struct {
|
|
rest *RESTClient
|
|
}
|
|
|
|
func (c userCommandClient) ExecuteCommand(ctx context.Context, command downstream.AuthenticatedCommand) (downstream.UnaryResult, error) {
|
|
return c.rest.ExecuteUserCommand(ctx, command)
|
|
}
|
|
|
|
type lobbyCommandClient struct {
|
|
rest *RESTClient
|
|
}
|
|
|
|
func (c lobbyCommandClient) ExecuteCommand(ctx context.Context, command downstream.AuthenticatedCommand) (downstream.UnaryResult, error) {
|
|
return c.rest.ExecuteLobbyCommand(ctx, command)
|
|
}
|
|
|
|
type gameCommandClient struct {
|
|
rest *RESTClient
|
|
}
|
|
|
|
func (c gameCommandClient) ExecuteCommand(ctx context.Context, command downstream.AuthenticatedCommand) (downstream.UnaryResult, error) {
|
|
return c.rest.ExecuteGameCommand(ctx, command)
|
|
}
|
|
|
|
var (
|
|
_ downstream.Client = unavailableClient{}
|
|
_ downstream.Client = userCommandClient{}
|
|
_ downstream.Client = lobbyCommandClient{}
|
|
_ downstream.Client = gameCommandClient{}
|
|
)
|