feat: user service

2026-04-10 19:05:02 +02:00
parent 710bad712e
commit 23ffcb7535
140 changed files with 33418 additions and 952 deletions
@@ -0,0 +1,397 @@
+// Package lobbyeligibility implements the trusted lobby-facing eligibility
+// snapshot read owned by User Service.
+package lobbyeligibility
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"time"
+
+	"galaxy/user/internal/domain/common"
+	"galaxy/user/internal/domain/entitlement"
+	"galaxy/user/internal/domain/policy"
+	"galaxy/user/internal/ports"
+	"galaxy/user/internal/service/shared"
+)
+
+// limitCatalogEntry stores one frozen default quota for free and paid
+// entitlement states.
+type limitCatalogEntry struct {
+	code        policy.LimitCode
+	freeValue   int
+	paidValue   int
+	freeEnabled bool
+}
+
+// limitCatalog stores the frozen lobby-facing effective limit defaults used
+// to materialize numeric quotas from the current entitlement state.
+var limitCatalog = []limitCatalogEntry{
+	{
+		code:      policy.LimitCodeMaxOwnedPrivateGames,
+		paidValue: 3,
+	},
+	{
+		code:        policy.LimitCodeMaxPendingPublicApplications,
+		freeValue:   3,
+		paidValue:   10,
+		freeEnabled: true,
+	},
+	{
+		code:        policy.LimitCodeMaxActiveGameMemberships,
+		freeValue:   3,
+		paidValue:   10,
+		freeEnabled: true,
+	},
+}
+
+// ActorRefView stores transport-ready audit actor metadata.
+type ActorRefView struct {
+	// Type stores the machine-readable actor type.
+	Type string `json:"type"`
+
+	// ID stores the optional stable actor identifier.
+	ID string `json:"id,omitempty"`
+}
+
+// EntitlementSnapshotView stores the transport-ready current entitlement
+// snapshot used by lobby reads.
+type EntitlementSnapshotView struct {
+	// PlanCode stores the effective entitlement plan code.
+	PlanCode string `json:"plan_code"`
+
+	// IsPaid reports whether the effective plan is paid.
+	IsPaid bool `json:"is_paid"`
+
+	// Source stores the machine-readable mutation source.
+	Source string `json:"source"`
+
+	// Actor stores the audit actor metadata attached to the snapshot.
+	Actor ActorRefView `json:"actor"`
+
+	// ReasonCode stores the machine-readable reason attached to the snapshot.
+	ReasonCode string `json:"reason_code"`
+
+	// StartsAt stores when the effective state started.
+	StartsAt time.Time `json:"starts_at"`
+
+	// EndsAt stores the optional finite effective expiry.
+	EndsAt *time.Time `json:"ends_at,omitempty"`
+
+	// UpdatedAt stores when the snapshot was last recomputed.
+	UpdatedAt time.Time `json:"updated_at"`
+}
+
+// ActiveSanctionView stores one transport-ready active sanction that matters
+// to lobby flows.
+type ActiveSanctionView struct {
+	// SanctionCode stores the active sanction code.
+	SanctionCode string `json:"sanction_code"`
+
+	// Scope stores the machine-readable sanction scope.
+	Scope string `json:"scope"`
+
+	// ReasonCode stores the machine-readable sanction reason.
+	ReasonCode string `json:"reason_code"`
+
+	// Actor stores the audit actor metadata attached to the sanction.
+	Actor ActorRefView `json:"actor"`
+
+	// AppliedAt stores when the sanction became active.
+	AppliedAt time.Time `json:"applied_at"`
+
+	// ExpiresAt stores the optional planned sanction expiry.
+	ExpiresAt *time.Time `json:"expires_at,omitempty"`
+}
+
+// EffectiveLimitView stores one materialized effective lobby quota.
+type EffectiveLimitView struct {
+	// LimitCode stores the machine-readable quota identifier.
+	LimitCode string `json:"limit_code"`
+
+	// Value stores the effective numeric quota after defaults and user
+	// overrides are applied.
+	Value int `json:"value"`
+}
+
+// EligibilityMarkersView stores the derived booleans consumed by Game Lobby.
+type EligibilityMarkersView struct {
+	// CanLogin reports whether the user may currently log in.
+	CanLogin bool `json:"can_login"`
+
+	// CanCreatePrivateGame reports whether the user may currently create a
+	// private game.
+	CanCreatePrivateGame bool `json:"can_create_private_game"`
+
+	// CanManagePrivateGame reports whether the user may currently manage a
+	// private game.
+	CanManagePrivateGame bool `json:"can_manage_private_game"`
+
+	// CanJoinGame reports whether the user may currently join a game.
+	CanJoinGame bool `json:"can_join_game"`
+
+	// CanUpdateProfile reports whether the user may currently update self-
+	// service profile and settings fields.
+	CanUpdateProfile bool `json:"can_update_profile"`
+}
+
+// GetUserEligibilityInput stores one lobby-facing eligibility read request.
+type GetUserEligibilityInput struct {
+	// UserID identifies the regular user whose effective lobby state is needed.
+	UserID string
+}
+
+// GetUserEligibilityResult stores one lobby-facing eligibility snapshot.
+type GetUserEligibilityResult struct {
+	// Exists reports whether UserID currently identifies a stored user.
+	Exists bool `json:"exists"`
+
+	// UserID echoes the requested stable user identifier.
+	UserID string `json:"user_id"`
+
+	// Entitlement stores the current effective entitlement snapshot for known
+	// users.
+	Entitlement *EntitlementSnapshotView `json:"entitlement,omitempty"`
+
+	// ActiveSanctions stores only the currently active sanctions relevant to
+	// lobby decisions.
+	ActiveSanctions []ActiveSanctionView `json:"active_sanctions"`
+
+	// EffectiveLimits stores the materialized numeric quotas used by Game
+	// Lobby.
+	EffectiveLimits []EffectiveLimitView `json:"effective_limits"`
+
+	// Markers stores the derived decision booleans consumed by Game Lobby.
+	Markers EligibilityMarkersView `json:"markers"`
+}
+
+type entitlementReader interface {
+	GetByUserID(ctx context.Context, userID common.UserID) (entitlement.CurrentSnapshot, error)
+}
+
+// SnapshotReader executes the trusted lobby-facing eligibility snapshot read.
+type SnapshotReader struct {
+	accounts     ports.UserAccountStore
+	entitlements entitlementReader
+	sanctions    ports.SanctionStore
+	limits       ports.LimitStore
+	clock        ports.Clock
+}
+
+// NewSnapshotReader constructs one lobby-facing eligibility snapshot reader.
+func NewSnapshotReader(
+	accounts ports.UserAccountStore,
+	entitlements entitlementReader,
+	sanctions ports.SanctionStore,
+	limits ports.LimitStore,
+	clock ports.Clock,
+) (*SnapshotReader, error) {
+	switch {
+	case accounts == nil:
+		return nil, fmt.Errorf("lobby eligibility snapshot reader: user account store must not be nil")
+	case entitlements == nil:
+		return nil, fmt.Errorf("lobby eligibility snapshot reader: entitlement reader must not be nil")
+	case sanctions == nil:
+		return nil, fmt.Errorf("lobby eligibility snapshot reader: sanction store must not be nil")
+	case limits == nil:
+		return nil, fmt.Errorf("lobby eligibility snapshot reader: limit store must not be nil")
+	case clock == nil:
+		return nil, fmt.Errorf("lobby eligibility snapshot reader: clock must not be nil")
+	default:
+		return &SnapshotReader{
+			accounts:     accounts,
+			entitlements: entitlements,
+			sanctions:    sanctions,
+			limits:       limits,
+			clock:        clock,
+		}, nil
+	}
+}
+
+// Execute returns one read-optimized eligibility snapshot for Game Lobby.
+func (service *SnapshotReader) Execute(
+	ctx context.Context,
+	input GetUserEligibilityInput,
+) (GetUserEligibilityResult, error) {
+	if ctx == nil {
+		return GetUserEligibilityResult{}, shared.InvalidRequest("context must not be nil")
+	}
+
+	userID, err := shared.ParseUserID(input.UserID)
+	if err != nil {
+		return GetUserEligibilityResult{}, err
+	}
+
+	result := GetUserEligibilityResult{
+		UserID:          userID.String(),
+		ActiveSanctions: []ActiveSanctionView{},
+		EffectiveLimits: []EffectiveLimitView{},
+	}
+
+	exists, err := service.accounts.ExistsByUserID(ctx, userID)
+	if err != nil {
+		return GetUserEligibilityResult{}, shared.ServiceUnavailable(err)
+	}
+	if !exists {
+		return result, nil
+	}
+
+	now := service.clock.Now().UTC()
+
+	entitlementSnapshot, err := service.entitlements.GetByUserID(ctx, userID)
+	switch {
+	case err == nil:
+	case errors.Is(err, ports.ErrNotFound):
+		return GetUserEligibilityResult{}, shared.InternalError(fmt.Errorf("user %q is missing entitlement snapshot", userID))
+	default:
+		return GetUserEligibilityResult{}, shared.ServiceUnavailable(err)
+	}
+
+	sanctionRecords, err := service.sanctions.ListByUserID(ctx, userID)
+	if err != nil {
+		return GetUserEligibilityResult{}, shared.ServiceUnavailable(err)
+	}
+	activeSanctions, err := policy.ActiveSanctionsAt(sanctionRecords, now)
+	if err != nil {
+		return GetUserEligibilityResult{}, shared.InternalError(fmt.Errorf("evaluate active sanctions for user %q: %w", userID, err))
+	}
+
+	limitRecords, err := service.limits.ListByUserID(ctx, userID)
+	if err != nil {
+		return GetUserEligibilityResult{}, shared.ServiceUnavailable(err)
+	}
+	activeLimits, err := policy.ActiveLimitsAt(limitRecords, now)
+	if err != nil {
+		return GetUserEligibilityResult{}, shared.InternalError(fmt.Errorf("evaluate active limits for user %q: %w", userID, err))
+	}
+
+	result.Exists = true
+	result.Entitlement = entitlementSnapshotView(entitlementSnapshot)
+	result.ActiveSanctions = lobbyRelevantSanctionViews(activeSanctions)
+	result.EffectiveLimits = materializeEffectiveLimits(entitlementSnapshot.IsPaid, activeLimits)
+	result.Markers = deriveEligibilityMarkers(entitlementSnapshot.IsPaid, activeSanctions)
+
+	return result, nil
+}
+
+func entitlementSnapshotView(snapshot entitlement.CurrentSnapshot) *EntitlementSnapshotView {
+	return &EntitlementSnapshotView{
+		PlanCode:   string(snapshot.PlanCode),
+		IsPaid:     snapshot.IsPaid,
+		Source:     snapshot.Source.String(),
+		Actor:      actorRefView(snapshot.Actor),
+		ReasonCode: snapshot.ReasonCode.String(),
+		StartsAt:   snapshot.StartsAt.UTC(),
+		EndsAt:     cloneOptionalTime(snapshot.EndsAt),
+		UpdatedAt:  snapshot.UpdatedAt.UTC(),
+	}
+}
+
+func lobbyRelevantSanctionViews(records []policy.SanctionRecord) []ActiveSanctionView {
+	views := make([]ActiveSanctionView, 0, len(records))
+
+	for _, record := range records {
+		if !isLobbyRelevantSanction(record.SanctionCode) {
+			continue
+		}
+
+		views = append(views, ActiveSanctionView{
+			SanctionCode: string(record.SanctionCode),
+			Scope:        record.Scope.String(),
+			ReasonCode:   record.ReasonCode.String(),
+			Actor:        actorRefView(record.Actor),
+			AppliedAt:    record.AppliedAt.UTC(),
+			ExpiresAt:    cloneOptionalTime(record.ExpiresAt),
+		})
+	}
+
+	return views
+}
+
+func materializeEffectiveLimits(isPaid bool, overrides []policy.LimitRecord) []EffectiveLimitView {
+	overrideValues := make(map[policy.LimitCode]int, len(overrides))
+	for _, record := range overrides {
+		overrideValues[record.LimitCode] = record.Value
+	}
+
+	limits := make([]EffectiveLimitView, 0, len(limitCatalog))
+	for _, entry := range limitCatalog {
+		if !isPaid && !entry.freeEnabled {
+			continue
+		}
+
+		value := entry.freeValue
+		if isPaid {
+			value = entry.paidValue
+		}
+		if override, ok := overrideValues[entry.code]; ok {
+			value = override
+		}
+
+		limits = append(limits, EffectiveLimitView{
+			LimitCode: string(entry.code),
+			Value:     value,
+		})
+	}
+
+	return limits
+}
+
+func deriveEligibilityMarkers(
+	isPaid bool,
+	activeSanctions []policy.SanctionRecord,
+) EligibilityMarkersView {
+	loginBlocked := hasActiveSanction(activeSanctions, policy.SanctionCodeLoginBlock)
+	createBlocked := hasActiveSanction(activeSanctions, policy.SanctionCodePrivateGameCreateBlock)
+	manageBlocked := hasActiveSanction(activeSanctions, policy.SanctionCodePrivateGameManageBlock)
+	joinBlocked := hasActiveSanction(activeSanctions, policy.SanctionCodeGameJoinBlock)
+	profileBlocked := hasActiveSanction(activeSanctions, policy.SanctionCodeProfileUpdateBlock)
+
+	canLogin := !loginBlocked
+
+	return EligibilityMarkersView{
+		CanLogin:             canLogin,
+		CanCreatePrivateGame: canLogin && isPaid && !createBlocked,
+		CanManagePrivateGame: canLogin && isPaid && !manageBlocked,
+		CanJoinGame:          canLogin && !joinBlocked,
+		CanUpdateProfile:     canLogin && !profileBlocked,
+	}
+}
+
+func hasActiveSanction(records []policy.SanctionRecord, code policy.SanctionCode) bool {
+	for _, record := range records {
+		if record.SanctionCode == code {
+			return true
+		}
+	}
+
+	return false
+}
+
+func isLobbyRelevantSanction(code policy.SanctionCode) bool {
+	switch code {
+	case policy.SanctionCodeLoginBlock,
+		policy.SanctionCodePrivateGameCreateBlock,
+		policy.SanctionCodePrivateGameManageBlock,
+		policy.SanctionCodeGameJoinBlock:
+		return true
+	default:
+		return false
+	}
+}
+
+func actorRefView(actor common.ActorRef) ActorRefView {
+	return ActorRefView{
+		Type: actor.Type.String(),
+		ID:   actor.ID.String(),
+	}
+}
+
+func cloneOptionalTime(value *time.Time) *time.Time {
+	if value == nil {
+		return nil
+	}
+
+	cloned := value.UTC()
+	return &cloned
+}