feat: use postgres

2026-04-26 20:34:39 +02:00
parent 48b0056b49
commit fe829285a6
365 changed files with 29223 additions and 24049 deletions
@@ -0,0 +1,346 @@
+// Package membershipstore implements the PostgreSQL-backed adapter for
+// `ports.MembershipStore`.
+//
+// PG_PLAN.md §6A migrates Game Lobby Service away from Redis-backed durable
+// membership records.
+package membershipstore
+
+import (
+	"context"
+	"database/sql"
+	"errors"
+	"fmt"
+	"strings"
+	"time"
+
+	"galaxy/lobby/internal/adapters/postgres/internal/sqlx"
+	pgtable "galaxy/lobby/internal/adapters/postgres/jet/lobby/table"
+	"galaxy/lobby/internal/domain/common"
+	"galaxy/lobby/internal/domain/membership"
+	"galaxy/lobby/internal/ports"
+
+	pg "github.com/go-jet/jet/v2/postgres"
+)
+
+// Config configures one PostgreSQL-backed membership store instance.
+type Config struct {
+	DB               *sql.DB
+	OperationTimeout time.Duration
+}
+
+// Store persists Game Lobby membership records in PostgreSQL.
+type Store struct {
+	db               *sql.DB
+	operationTimeout time.Duration
+}
+
+// New constructs one PostgreSQL-backed membership store from cfg.
+func New(cfg Config) (*Store, error) {
+	if cfg.DB == nil {
+		return nil, errors.New("new postgres membership store: db must not be nil")
+	}
+	if cfg.OperationTimeout <= 0 {
+		return nil, errors.New("new postgres membership store: operation timeout must be positive")
+	}
+	return &Store{
+		db:               cfg.DB,
+		operationTimeout: cfg.OperationTimeout,
+	}, nil
+}
+
+// membershipSelectColumns is the canonical SELECT list for the memberships
+// table, matching scanMembership's column order.
+var membershipSelectColumns = pg.ColumnList{
+	pgtable.Memberships.MembershipID,
+	pgtable.Memberships.GameID,
+	pgtable.Memberships.UserID,
+	pgtable.Memberships.RaceName,
+	pgtable.Memberships.CanonicalKey,
+	pgtable.Memberships.Status,
+	pgtable.Memberships.JoinedAt,
+	pgtable.Memberships.RemovedAt,
+}
+
+// Save persists a new active membership record. Save is create-only; a
+// second save against the same membership id maps the unique-violation to
+// membership.ErrConflict.
+func (store *Store) Save(ctx context.Context, record membership.Membership) error {
+	if store == nil || store.db == nil {
+		return errors.New("save membership: nil store")
+	}
+	if err := record.Validate(); err != nil {
+		return fmt.Errorf("save membership: %w", err)
+	}
+	if record.Status != membership.StatusActive {
+		return fmt.Errorf(
+			"save membership: status must be %q, got %q",
+			membership.StatusActive, record.Status,
+		)
+	}
+
+	operationCtx, cancel, err := sqlx.WithTimeout(ctx, "save membership", store.operationTimeout)
+	if err != nil {
+		return err
+	}
+	defer cancel()
+
+	stmt := pgtable.Memberships.INSERT(
+		pgtable.Memberships.MembershipID,
+		pgtable.Memberships.GameID,
+		pgtable.Memberships.UserID,
+		pgtable.Memberships.RaceName,
+		pgtable.Memberships.CanonicalKey,
+		pgtable.Memberships.Status,
+		pgtable.Memberships.JoinedAt,
+		pgtable.Memberships.RemovedAt,
+	).VALUES(
+		record.MembershipID.String(),
+		record.GameID.String(),
+		record.UserID,
+		record.RaceName,
+		record.CanonicalKey,
+		string(record.Status),
+		record.JoinedAt.UTC(),
+		sqlx.NullableTimePtr(record.RemovedAt),
+	)
+
+	query, args := stmt.Sql()
+	if _, err := store.db.ExecContext(operationCtx, query, args...); err != nil {
+		if sqlx.IsUniqueViolation(err) {
+			return fmt.Errorf("save membership: %w", membership.ErrConflict)
+		}
+		return fmt.Errorf("save membership: %w", err)
+	}
+	return nil
+}
+
+// Get returns the record identified by membershipID.
+func (store *Store) Get(ctx context.Context, membershipID common.MembershipID) (membership.Membership, error) {
+	if store == nil || store.db == nil {
+		return membership.Membership{}, errors.New("get membership: nil store")
+	}
+	if err := membershipID.Validate(); err != nil {
+		return membership.Membership{}, fmt.Errorf("get membership: %w", err)
+	}
+
+	operationCtx, cancel, err := sqlx.WithTimeout(ctx, "get membership", store.operationTimeout)
+	if err != nil {
+		return membership.Membership{}, err
+	}
+	defer cancel()
+
+	stmt := pg.SELECT(membershipSelectColumns).
+		FROM(pgtable.Memberships).
+		WHERE(pgtable.Memberships.MembershipID.EQ(pg.String(membershipID.String())))
+
+	query, args := stmt.Sql()
+	row := store.db.QueryRowContext(operationCtx, query, args...)
+	record, err := scanMembership(row)
+	if sqlx.IsNoRows(err) {
+		return membership.Membership{}, membership.ErrNotFound
+	}
+	if err != nil {
+		return membership.Membership{}, fmt.Errorf("get membership: %w", err)
+	}
+	return record, nil
+}
+
+// GetByGame returns every membership attached to gameID.
+func (store *Store) GetByGame(ctx context.Context, gameID common.GameID) ([]membership.Membership, error) {
+	if store == nil || store.db == nil {
+		return nil, errors.New("get memberships by game: nil store")
+	}
+	if err := gameID.Validate(); err != nil {
+		return nil, fmt.Errorf("get memberships by game: %w", err)
+	}
+
+	stmt := pg.SELECT(membershipSelectColumns).
+		FROM(pgtable.Memberships).
+		WHERE(pgtable.Memberships.GameID.EQ(pg.String(gameID.String()))).
+		ORDER_BY(pgtable.Memberships.JoinedAt.ASC(), pgtable.Memberships.MembershipID.ASC())
+
+	return store.queryList(ctx, "get memberships by game", stmt)
+}
+
+// GetByUser returns every membership held by userID.
+func (store *Store) GetByUser(ctx context.Context, userID string) ([]membership.Membership, error) {
+	if store == nil || store.db == nil {
+		return nil, errors.New("get memberships by user: nil store")
+	}
+	trimmed := strings.TrimSpace(userID)
+	if trimmed == "" {
+		return nil, fmt.Errorf("get memberships by user: user id must not be empty")
+	}
+
+	stmt := pg.SELECT(membershipSelectColumns).
+		FROM(pgtable.Memberships).
+		WHERE(pgtable.Memberships.UserID.EQ(pg.String(trimmed))).
+		ORDER_BY(pgtable.Memberships.JoinedAt.ASC(), pgtable.Memberships.MembershipID.ASC())
+
+	return store.queryList(ctx, "get memberships by user", stmt)
+}
+
+func (store *Store) queryList(ctx context.Context, operation string, stmt pg.SelectStatement) ([]membership.Membership, error) {
+	operationCtx, cancel, err := sqlx.WithTimeout(ctx, operation, store.operationTimeout)
+	if err != nil {
+		return nil, err
+	}
+	defer cancel()
+
+	query, args := stmt.Sql()
+	rows, err := store.db.QueryContext(operationCtx, query, args...)
+	if err != nil {
+		return nil, fmt.Errorf("%s: %w", operation, err)
+	}
+	defer rows.Close()
+
+	records := make([]membership.Membership, 0)
+	for rows.Next() {
+		record, err := scanMembership(rows)
+		if err != nil {
+			return nil, fmt.Errorf("%s: scan: %w", operation, err)
+		}
+		records = append(records, record)
+	}
+	if err := rows.Err(); err != nil {
+		return nil, fmt.Errorf("%s: %w", operation, err)
+	}
+	if len(records) == 0 {
+		return nil, nil
+	}
+	return records, nil
+}
+
+// UpdateStatus applies one status transition with compare-and-swap on the
+// current status column. RemovedAt is set to input.At when transitioning out
+// of active.
+func (store *Store) UpdateStatus(ctx context.Context, input ports.UpdateMembershipStatusInput) error {
+	if store == nil || store.db == nil {
+		return errors.New("update membership status: nil store")
+	}
+	if err := input.Validate(); err != nil {
+		return fmt.Errorf("update membership status: %w", err)
+	}
+	if err := membership.Transition(input.ExpectedFrom, input.To); err != nil {
+		return err
+	}
+
+	operationCtx, cancel, err := sqlx.WithTimeout(ctx, "update membership status", store.operationTimeout)
+	if err != nil {
+		return err
+	}
+	defer cancel()
+
+	at := input.At.UTC()
+	stmt := pgtable.Memberships.UPDATE(pgtable.Memberships.Status, pgtable.Memberships.RemovedAt).
+		SET(string(input.To), at).
+		WHERE(pg.AND(
+			pgtable.Memberships.MembershipID.EQ(pg.String(input.MembershipID.String())),
+			pgtable.Memberships.Status.EQ(pg.String(string(input.ExpectedFrom))),
+		))
+
+	query, args := stmt.Sql()
+	result, err := store.db.ExecContext(operationCtx, query, args...)
+	if err != nil {
+		return fmt.Errorf("update membership status: %w", err)
+	}
+	affected, err := result.RowsAffected()
+	if err != nil {
+		return fmt.Errorf("update membership status: rows affected: %w", err)
+	}
+	if affected == 0 {
+		probe := pg.SELECT(pgtable.Memberships.Status).
+			FROM(pgtable.Memberships).
+			WHERE(pgtable.Memberships.MembershipID.EQ(pg.String(input.MembershipID.String())))
+		probeQuery, probeArgs := probe.Sql()
+
+		var current string
+		row := store.db.QueryRowContext(operationCtx, probeQuery, probeArgs...)
+		if err := row.Scan(&current); err != nil {
+			if sqlx.IsNoRows(err) {
+				return membership.ErrNotFound
+			}
+			return fmt.Errorf("update membership status: probe: %w", err)
+		}
+		return fmt.Errorf("update membership status: %w", membership.ErrConflict)
+	}
+	return nil
+}
+
+// Delete removes the membership record identified by membershipID. The
+// pre-start removemember path uses Delete; the post-start path uses
+// UpdateStatus(active → removed).
+func (store *Store) Delete(ctx context.Context, membershipID common.MembershipID) error {
+	if store == nil || store.db == nil {
+		return errors.New("delete membership: nil store")
+	}
+	if err := membershipID.Validate(); err != nil {
+		return fmt.Errorf("delete membership: %w", err)
+	}
+
+	operationCtx, cancel, err := sqlx.WithTimeout(ctx, "delete membership", store.operationTimeout)
+	if err != nil {
+		return err
+	}
+	defer cancel()
+
+	stmt := pgtable.Memberships.DELETE().
+		WHERE(pgtable.Memberships.MembershipID.EQ(pg.String(membershipID.String())))
+
+	query, args := stmt.Sql()
+	result, err := store.db.ExecContext(operationCtx, query, args...)
+	if err != nil {
+		return fmt.Errorf("delete membership: %w", err)
+	}
+	affected, err := result.RowsAffected()
+	if err != nil {
+		return fmt.Errorf("delete membership: rows affected: %w", err)
+	}
+	if affected == 0 {
+		return membership.ErrNotFound
+	}
+	return nil
+}
+
+type rowScanner interface {
+	Scan(dest ...any) error
+}
+
+func scanMembership(rs rowScanner) (membership.Membership, error) {
+	var (
+		membershipID string
+		gameID       string
+		userID       string
+		raceName     string
+		canonicalKey string
+		status       string
+		joinedAt     time.Time
+		removedAt    sql.NullTime
+	)
+	if err := rs.Scan(
+		&membershipID,
+		&gameID,
+		&userID,
+		&raceName,
+		&canonicalKey,
+		&status,
+		&joinedAt,
+		&removedAt,
+	); err != nil {
+		return membership.Membership{}, err
+	}
+	return membership.Membership{
+		MembershipID: common.MembershipID(membershipID),
+		GameID:       common.GameID(gameID),
+		UserID:       userID,
+		RaceName:     raceName,
+		CanonicalKey: canonicalKey,
+		Status:       membership.Status(status),
+		JoinedAt:     joinedAt.UTC(),
+		RemovedAt:    sqlx.TimePtrFromNullable(removedAt),
+	}, nil
+}
+
+// Ensure Store satisfies the ports.MembershipStore interface at compile
+// time.
+var _ ports.MembershipStore = (*Store)(nil)