feat: game lobby service

pkg/transcoder/notification.go

@@ -42,6 +42,16 @@ type LobbyMembershipRejectedEvent struct {
 	GameID string
 }
 
+// LobbyMembershipBlockedEvent is the independent Go representation of
+// `notification.LobbyMembershipBlockedEvent`. Reason carries the upstream
+// lifecycle event that triggered the cascade
+// (`permanent_blocked`, `deleted`).
+type LobbyMembershipBlockedEvent struct {
+	GameID           string
+	MembershipUserID string
+	Reason           string
+}
+
 // LobbyInviteCreatedEvent is the independent Go representation of
 // `notification.LobbyInviteCreatedEvent`.
 type LobbyInviteCreatedEvent struct {
@@ -56,6 +66,20 @@ type LobbyInviteRedeemedEvent struct {
 	InviteeUserID string
 }
 
+// LobbyRaceNameRegistrationEligibleEvent is the independent Go
+// representation of `notification.LobbyRaceNameRegistrationEligibleEvent`.
+type LobbyRaceNameRegistrationEligibleEvent struct {
+	GameID          string
+	RaceName        string
+	EligibleUntilMs int64
+}
+
+// LobbyRaceNameRegisteredEvent is the independent Go representation of
+// `notification.LobbyRaceNameRegisteredEvent`.
+type LobbyRaceNameRegisteredEvent struct {
+	RaceName string
+}
+
 // GameTurnReadyEventToPayload converts GameTurnReadyEvent to FlatBuffers bytes
 // suitable for the authenticated gateway push transport.
 func GameTurnReadyEventToPayload(event *GameTurnReadyEvent) ([]byte, error) {
@@ -272,6 +296,68 @@ func PayloadToLobbyMembershipRejectedEvent(data []byte) (result *LobbyMembership
 	return &LobbyMembershipRejectedEvent{GameID: gameID}, nil
 }
 
+// LobbyMembershipBlockedEventToPayload converts LobbyMembershipBlockedEvent
+// to FlatBuffers bytes suitable for the authenticated gateway push
+// transport.
+func LobbyMembershipBlockedEventToPayload(event *LobbyMembershipBlockedEvent) ([]byte, error) {
+	if event == nil {
+		return nil, errors.New("encode lobby membership blocked payload: event is nil")
+	}
+	if event.GameID == "" {
+		return nil, errors.New("encode lobby membership blocked payload: game_id is empty")
+	}
+	if event.MembershipUserID == "" {
+		return nil, errors.New("encode lobby membership blocked payload: membership_user_id is empty")
+	}
+	if event.Reason == "" {
+		return nil, errors.New("encode lobby membership blocked payload: reason is empty")
+	}
+
+	builder := flatbuffers.NewBuilder(96)
+	gameID := builder.CreateString(event.GameID)
+	membershipUserID := builder.CreateString(event.MembershipUserID)
+	reason := builder.CreateString(event.Reason)
+
+	notificationfbs.LobbyMembershipBlockedEventStart(builder)
+	notificationfbs.LobbyMembershipBlockedEventAddGameId(builder, gameID)
+	notificationfbs.LobbyMembershipBlockedEventAddMembershipUserId(builder, membershipUserID)
+	notificationfbs.LobbyMembershipBlockedEventAddReason(builder, reason)
+	offset := notificationfbs.LobbyMembershipBlockedEventEnd(builder)
+	notificationfbs.FinishLobbyMembershipBlockedEventBuffer(builder, offset)
+
+	return builder.FinishedBytes(), nil
+}
+
+// PayloadToLobbyMembershipBlockedEvent converts FlatBuffers payload bytes
+// into LobbyMembershipBlockedEvent.
+func PayloadToLobbyMembershipBlockedEvent(data []byte) (result *LobbyMembershipBlockedEvent, err error) {
+	if len(data) == 0 {
+		return nil, errors.New("decode lobby membership blocked payload: data is empty")
+	}
+
+	defer recoverNotificationDecodePanic("decode lobby membership blocked payload", &result, &err)
+
+	event := notificationfbs.GetRootAsLobbyMembershipBlockedEvent(data, 0)
+	gameID, err := requiredNotificationString(event.GameId(), "game_id")
+	if err != nil {
+		return nil, fmt.Errorf("decode lobby membership blocked payload: %w", err)
+	}
+	membershipUserID, err := requiredNotificationString(event.MembershipUserId(), "membership_user_id")
+	if err != nil {
+		return nil, fmt.Errorf("decode lobby membership blocked payload: %w", err)
+	}
+	reason, err := requiredNotificationString(event.Reason(), "reason")
+	if err != nil {
+		return nil, fmt.Errorf("decode lobby membership blocked payload: %w", err)
+	}
+
+	return &LobbyMembershipBlockedEvent{
+		GameID:           gameID,
+		MembershipUserID: membershipUserID,
+		Reason:           reason,
+	}, nil
+}
+
 // LobbyInviteCreatedEventToPayload converts LobbyInviteCreatedEvent to
 // FlatBuffers bytes suitable for the authenticated gateway push transport.
 func LobbyInviteCreatedEventToPayload(event *LobbyInviteCreatedEvent) ([]byte, error) {
@@ -374,6 +460,99 @@ func PayloadToLobbyInviteRedeemedEvent(data []byte) (result *LobbyInviteRedeemed
 	}, nil
 }
 
+// LobbyRaceNameRegistrationEligibleEventToPayload converts
+// LobbyRaceNameRegistrationEligibleEvent to FlatBuffers bytes suitable for
+// the authenticated gateway push transport.
+func LobbyRaceNameRegistrationEligibleEventToPayload(event *LobbyRaceNameRegistrationEligibleEvent) ([]byte, error) {
+	if event == nil {
+		return nil, errors.New("encode lobby race name registration eligible payload: event is nil")
+	}
+	if event.GameID == "" {
+		return nil, errors.New("encode lobby race name registration eligible payload: game_id is empty")
+	}
+	if event.RaceName == "" {
+		return nil, errors.New("encode lobby race name registration eligible payload: race_name is empty")
+	}
+
+	builder := flatbuffers.NewBuilder(96)
+	gameID := builder.CreateString(event.GameID)
+	raceName := builder.CreateString(event.RaceName)
+
+	notificationfbs.LobbyRaceNameRegistrationEligibleEventStart(builder)
+	notificationfbs.LobbyRaceNameRegistrationEligibleEventAddGameId(builder, gameID)
+	notificationfbs.LobbyRaceNameRegistrationEligibleEventAddRaceName(builder, raceName)
+	notificationfbs.LobbyRaceNameRegistrationEligibleEventAddEligibleUntilMs(builder, event.EligibleUntilMs)
+	offset := notificationfbs.LobbyRaceNameRegistrationEligibleEventEnd(builder)
+	notificationfbs.FinishLobbyRaceNameRegistrationEligibleEventBuffer(builder, offset)
+
+	return builder.FinishedBytes(), nil
+}
+
+// PayloadToLobbyRaceNameRegistrationEligibleEvent converts FlatBuffers
+// payload bytes into LobbyRaceNameRegistrationEligibleEvent.
+func PayloadToLobbyRaceNameRegistrationEligibleEvent(data []byte) (result *LobbyRaceNameRegistrationEligibleEvent, err error) {
+	if len(data) == 0 {
+		return nil, errors.New("decode lobby race name registration eligible payload: data is empty")
+	}
+
+	defer recoverNotificationDecodePanic("decode lobby race name registration eligible payload", &result, &err)
+
+	event := notificationfbs.GetRootAsLobbyRaceNameRegistrationEligibleEvent(data, 0)
+	gameID, err := requiredNotificationString(event.GameId(), "game_id")
+	if err != nil {
+		return nil, fmt.Errorf("decode lobby race name registration eligible payload: %w", err)
+	}
+	raceName, err := requiredNotificationString(event.RaceName(), "race_name")
+	if err != nil {
+		return nil, fmt.Errorf("decode lobby race name registration eligible payload: %w", err)
+	}
+
+	return &LobbyRaceNameRegistrationEligibleEvent{
+		GameID:          gameID,
+		RaceName:        raceName,
+		EligibleUntilMs: event.EligibleUntilMs(),
+	}, nil
+}
+
+// LobbyRaceNameRegisteredEventToPayload converts LobbyRaceNameRegisteredEvent
+// to FlatBuffers bytes suitable for the authenticated gateway push transport.
+func LobbyRaceNameRegisteredEventToPayload(event *LobbyRaceNameRegisteredEvent) ([]byte, error) {
+	if event == nil {
+		return nil, errors.New("encode lobby race name registered payload: event is nil")
+	}
+	if event.RaceName == "" {
+		return nil, errors.New("encode lobby race name registered payload: race_name is empty")
+	}
+
+	builder := flatbuffers.NewBuilder(48)
+	raceName := builder.CreateString(event.RaceName)
+
+	notificationfbs.LobbyRaceNameRegisteredEventStart(builder)
+	notificationfbs.LobbyRaceNameRegisteredEventAddRaceName(builder, raceName)
+	offset := notificationfbs.LobbyRaceNameRegisteredEventEnd(builder)
+	notificationfbs.FinishLobbyRaceNameRegisteredEventBuffer(builder, offset)
+
+	return builder.FinishedBytes(), nil
+}
+
+// PayloadToLobbyRaceNameRegisteredEvent converts FlatBuffers payload bytes
+// into LobbyRaceNameRegisteredEvent.
+func PayloadToLobbyRaceNameRegisteredEvent(data []byte) (result *LobbyRaceNameRegisteredEvent, err error) {
+	if len(data) == 0 {
+		return nil, errors.New("decode lobby race name registered payload: data is empty")
+	}
+
+	defer recoverNotificationDecodePanic("decode lobby race name registered payload", &result, &err)
+
+	event := notificationfbs.GetRootAsLobbyRaceNameRegisteredEvent(data, 0)
+	raceName, err := requiredNotificationString(event.RaceName(), "race_name")
+	if err != nil {
+		return nil, fmt.Errorf("decode lobby race name registered payload: %w", err)
+	}
+
+	return &LobbyRaceNameRegisteredEvent{RaceName: raceName}, nil
+}
+
 func requiredNotificationString(value []byte, field string) (string, error) {
 	if len(value) == 0 {
 		return "", fmt.Errorf("%s is missing", field)