games/db/repository/games.sql.go

// Code generated by sqlc. DO NOT EDIT.
// versions:
//   sqlc v1.30.0
// source: games.sql

package repository

import (
	"context"
	"time"
)

const createGamePlayer = `-- name: CreateGamePlayer :exec
INSERT INTO game_players (game_id, user_id, guest_player_id, nickname, color, slot)
VALUES (?, ?, ?, ?, ?, ?)
`

type CreateGamePlayerParams struct {
	GameID        string  `db:"game_id" json:"game_id"`
	UserID        *string `db:"user_id" json:"user_id"`
	GuestPlayerID *string `db:"guest_player_id" json:"guest_player_id"`
	Nickname      string  `db:"nickname" json:"nickname"`
	Color         int64   `db:"color" json:"color"`
	Slot          int64   `db:"slot" json:"slot"`
}

func (q *Queries) CreateGamePlayer(ctx context.Context, arg CreateGamePlayerParams) error {
	_, err := q.db.ExecContext(ctx, createGamePlayer,
		arg.GameID,
		arg.UserID,
		arg.GuestPlayerID,
		arg.Nickname,
		arg.Color,
		arg.Slot,
	)
	return err
}

const deleteGame = `-- name: DeleteGame :exec
DELETE FROM games WHERE id = ?
`

func (q *Queries) DeleteGame(ctx context.Context, id string) error {
	_, err := q.db.ExecContext(ctx, deleteGame, id)
	return err
}

const getActiveGames = `-- name: GetActiveGames :many
SELECT id, board, current_turn, status, winner_user_id, winning_cells, created_at, updated_at, rematch_game_id, game_type, grid_width, grid_height, max_players, game_mode, score, snake_speed FROM games WHERE game_type = 'connect4' AND status < 2
`

func (q *Queries) GetActiveGames(ctx context.Context) ([]*Game, error) {
	rows, err := q.db.QueryContext(ctx, getActiveGames)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []*Game
	for rows.Next() {
		var i Game
		if err := rows.Scan(
			&i.ID,
			&i.Board,
			&i.CurrentTurn,
			&i.Status,
			&i.WinnerUserID,
			&i.WinningCells,
			&i.CreatedAt,
			&i.UpdatedAt,
			&i.RematchGameID,
			&i.GameType,
			&i.GridWidth,
			&i.GridHeight,
			&i.MaxPlayers,
			&i.GameMode,
			&i.Score,
			&i.SnakeSpeed,
		); err != nil {
			return nil, err
		}
		items = append(items, &i)
	}
	if err := rows.Close(); err != nil {
		return nil, err
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const getGame = `-- name: GetGame :one
SELECT id, board, current_turn, status, winner_user_id, winning_cells, created_at, updated_at, rematch_game_id, game_type, grid_width, grid_height, max_players, game_mode, score, snake_speed FROM games WHERE id = ?
`

func (q *Queries) GetGame(ctx context.Context, id string) (*Game, error) {
	row := q.db.QueryRowContext(ctx, getGame, id)
	var i Game
	err := row.Scan(
		&i.ID,
		&i.Board,
		&i.CurrentTurn,
		&i.Status,
		&i.WinnerUserID,
		&i.WinningCells,
		&i.CreatedAt,
		&i.UpdatedAt,
		&i.RematchGameID,
		&i.GameType,
		&i.GridWidth,
		&i.GridHeight,
		&i.MaxPlayers,
		&i.GameMode,
		&i.Score,
		&i.SnakeSpeed,
	)
	return &i, err
}

const getGamePlayers = `-- name: GetGamePlayers :many
SELECT game_id, user_id, guest_player_id, nickname, color, slot, created_at FROM game_players WHERE game_id = ?
`

func (q *Queries) GetGamePlayers(ctx context.Context, gameID string) ([]*GamePlayer, error) {
	rows, err := q.db.QueryContext(ctx, getGamePlayers, gameID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []*GamePlayer
	for rows.Next() {
		var i GamePlayer
		if err := rows.Scan(
			&i.GameID,
			&i.UserID,
			&i.GuestPlayerID,
			&i.Nickname,
			&i.Color,
			&i.Slot,
			&i.CreatedAt,
		); err != nil {
			return nil, err
		}
		items = append(items, &i)
	}
	if err := rows.Close(); err != nil {
		return nil, err
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const getGamesByUserID = `-- name: GetGamesByUserID :many
SELECT g.id, g.board, g.current_turn, g.status, g.winner_user_id, g.winning_cells, g.created_at, g.updated_at, g.rematch_game_id, g.game_type, g.grid_width, g.grid_height, g.max_players, g.game_mode, g.score, g.snake_speed FROM games g
JOIN game_players gp ON g.id = gp.game_id
WHERE gp.user_id = ?
ORDER BY g.updated_at DESC
`

func (q *Queries) GetGamesByUserID(ctx context.Context, userID *string) ([]*Game, error) {
	rows, err := q.db.QueryContext(ctx, getGamesByUserID, userID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []*Game
	for rows.Next() {
		var i Game
		if err := rows.Scan(
			&i.ID,
			&i.Board,
			&i.CurrentTurn,
			&i.Status,
			&i.WinnerUserID,
			&i.WinningCells,
			&i.CreatedAt,
			&i.UpdatedAt,
			&i.RematchGameID,
			&i.GameType,
			&i.GridWidth,
			&i.GridHeight,
			&i.MaxPlayers,
			&i.GameMode,
			&i.Score,
			&i.SnakeSpeed,
		); err != nil {
			return nil, err
		}
		items = append(items, &i)
	}
	if err := rows.Close(); err != nil {
		return nil, err
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const getUserActiveGames = `-- name: GetUserActiveGames :many
SELECT
    g.id,
    g.status,
    g.current_turn,
    g.updated_at,
    gp_user.color as my_color,
    gp_opponent.nickname as opponent_nickname
FROM games g
JOIN game_players gp_user ON g.id = gp_user.game_id AND gp_user.user_id = ?
LEFT JOIN game_players gp_opponent ON g.id = gp_opponent.game_id AND gp_opponent.slot != gp_user.slot
WHERE g.game_type = 'connect4' AND g.status < 2
ORDER BY g.updated_at DESC
`

type GetUserActiveGamesRow struct {
	ID               string     `db:"id" json:"id"`
	Status           int64      `db:"status" json:"status"`
	CurrentTurn      int64      `db:"current_turn" json:"current_turn"`
	UpdatedAt        *time.Time `db:"updated_at" json:"updated_at"`
	MyColor          int64      `db:"my_color" json:"my_color"`
	OpponentNickname *string    `db:"opponent_nickname" json:"opponent_nickname"`
}

func (q *Queries) GetUserActiveGames(ctx context.Context, userID *string) ([]*GetUserActiveGamesRow, error) {
	rows, err := q.db.QueryContext(ctx, getUserActiveGames, userID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []*GetUserActiveGamesRow
	for rows.Next() {
		var i GetUserActiveGamesRow
		if err := rows.Scan(
			&i.ID,
			&i.Status,
			&i.CurrentTurn,
			&i.UpdatedAt,
			&i.MyColor,
			&i.OpponentNickname,
		); err != nil {
			return nil, err
		}
		items = append(items, &i)
	}
	if err := rows.Close(); err != nil {
		return nil, err
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const upsertGame = `-- name: UpsertGame :exec
INSERT INTO games (id, board, current_turn, status, game_type, winner_user_id, winning_cells, rematch_game_id)
VALUES (?, ?, ?, ?, 'connect4', ?, ?, ?)
ON CONFLICT(id) DO UPDATE SET
    board = excluded.board,
    current_turn = excluded.current_turn,
    status = excluded.status,
    winner_user_id = excluded.winner_user_id,
    winning_cells = excluded.winning_cells,
    rematch_game_id = excluded.rematch_game_id,
    updated_at = CURRENT_TIMESTAMP
`

type UpsertGameParams struct {
	ID            string  `db:"id" json:"id"`
	Board         string  `db:"board" json:"board"`
	CurrentTurn   int64   `db:"current_turn" json:"current_turn"`
	Status        int64   `db:"status" json:"status"`
	WinnerUserID  *string `db:"winner_user_id" json:"winner_user_id"`
	WinningCells  *string `db:"winning_cells" json:"winning_cells"`
	RematchGameID *string `db:"rematch_game_id" json:"rematch_game_id"`
}

func (q *Queries) UpsertGame(ctx context.Context, arg UpsertGameParams) error {
	_, err := q.db.ExecContext(ctx, upsertGame,
		arg.ID,
		arg.Board,
		arg.CurrentTurn,
		arg.Status,
		arg.WinnerUserID,
		arg.WinningCells,
		arg.RematchGameID,
	)
	return err
}