v0.5.0 user support with auth added, tests and doc updated

internal/storage/game.go

@@ -0,0 +1,138 @@
+// FILE: internal/storage/game.go
+package storage
+
+import (
+	"database/sql"
+	"fmt"
+	"log"
+)
+
+// RecordNewGame asynchronously records a new game
+func (s *Store) RecordNewGame(record GameRecord) error {
+	if !s.healthStatus.Load() {
+		return nil // Silently drop if degraded
+	}
+
+	select {
+	case s.writeChan <- func(tx *sql.Tx) error {
+		query := `INSERT INTO games (
+			game_id, initial_fen, 
+			white_player_id, white_type, white_level, white_search_time,
+			black_player_id, black_type, black_level, black_search_time,
+			start_time_utc
+		) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+
+		_, err := tx.Exec(query,
+			record.GameID, record.InitialFEN,
+			record.WhitePlayerID, record.WhiteType, record.WhiteLevel, record.WhiteSearchTime,
+			record.BlackPlayerID, record.BlackType, record.BlackLevel, record.BlackSearchTime,
+			record.StartTimeUTC,
+		)
+		return err
+	}:
+		return nil
+	default:
+		// Channel full, drop write
+		log.Printf("Storage write queue full, dropping game record")
+		return nil
+	}
+}
+
+// RecordMove asynchronously records a move
+func (s *Store) RecordMove(record MoveRecord) error {
+	if !s.healthStatus.Load() {
+		return nil // Silently drop if degraded
+	}
+
+	select {
+	case s.writeChan <- func(tx *sql.Tx) error {
+		query := `INSERT INTO moves (
+			game_id, move_number, move_uci, fen_after_move, player_color, move_time_utc
+		) VALUES (?, ?, ?, ?, ?, ?)`
+
+		_, err := tx.Exec(query,
+			record.GameID, record.MoveNumber, record.MoveUCI,
+			record.FENAfterMove, record.PlayerColor, record.MoveTimeUTC,
+		)
+		return err
+	}:
+		return nil
+	default:
+		// Channel full, drop write
+		log.Printf("Storage write queue full, dropping move record")
+		return nil
+	}
+}
+
+// DeleteUndoneMoves asynchronously deletes moves after undo
+func (s *Store) DeleteUndoneMoves(gameID string, afterMoveNumber int) error {
+	if !s.healthStatus.Load() {
+		return nil // Silently drop if degraded
+	}
+
+	select {
+	case s.writeChan <- func(tx *sql.Tx) error {
+		query := `DELETE FROM moves WHERE game_id = ? AND move_number > ?`
+		_, err := tx.Exec(query, gameID, afterMoveNumber)
+		return err
+	}:
+		return nil
+	default:
+		// Channel full, drop write
+		log.Printf("Storage write queue full, dropping undo operation")
+		return nil
+	}
+}
+
+// QueryGames retrieves games with optional filtering
+func (s *Store) QueryGames(gameID, playerID string) ([]GameRecord, error) {
+	query := `SELECT 
+		game_id, initial_fen, 
+		white_player_id, white_type, white_level, white_search_time,
+		black_player_id, black_type, black_level, black_search_time,
+		start_time_utc
+	FROM games WHERE 1=1`
+
+	var args []interface{}
+
+	// Handle gameID filtering
+	if gameID != "" && gameID != "*" {
+		query += " AND game_id = ?"
+		args = append(args, gameID)
+	}
+
+	// Handle playerID filtering
+	if playerID != "" && playerID != "*" {
+		query += " AND (white_player_id = ? OR black_player_id = ?)"
+		args = append(args, playerID, playerID)
+	}
+
+	query += " ORDER BY start_time_utc DESC"
+
+	rows, err := s.db.Query(query, args...)
+	if err != nil {
+		return nil, fmt.Errorf("query failed: %w", err)
+	}
+	defer rows.Close()
+
+	var games []GameRecord
+	for rows.Next() {
+		var g GameRecord
+		err := rows.Scan(
+			&g.GameID, &g.InitialFEN,
+			&g.WhitePlayerID, &g.WhiteType, &g.WhiteLevel, &g.WhiteSearchTime,
+			&g.BlackPlayerID, &g.BlackType, &g.BlackLevel, &g.BlackSearchTime,
+			&g.StartTimeUTC,
+		)
+		if err != nil {
+			return nil, fmt.Errorf("scan failed: %w", err)
+		}
+		games = append(games, g)
+	}
+
+	if err := rows.Err(); err != nil {
+		return nil, fmt.Errorf("rows iteration failed: %w", err)
+	}
+
+	return games, nil
+}

internal/storage/schema.go

@@ -3,6 +3,16 @@ package storage
 
 import "time"
 
+// UserRecord represents a user account in the database
+type UserRecord struct {
+	UserID       string     `db:"user_id"`
+	Username     string     `db:"username"`
+	Email        string     `db:"email"`
+	PasswordHash string     `db:"password_hash"`
+	CreatedAt    time.Time  `db:"created_at"`
+	LastLoginAt  *time.Time `db:"last_login_at"`
+}
+
 // GameRecord represents a row in the games table
 type GameRecord struct {
 	GameID          string    `db:"game_id"`
@@ -31,6 +41,19 @@ type MoveRecord struct {
 
 // Schema defines the SQLite database structure
 const Schema = `
+CREATE TABLE IF NOT EXISTS users (
+	user_id TEXT PRIMARY KEY,
+	username TEXT UNIQUE NOT NULL COLLATE NOCASE,
+	email TEXT COLLATE NOCASE,
+	password_hash TEXT NOT NULL,
+	created_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+	last_login_at DATETIME
+);
+
+CREATE INDEX IF NOT EXISTS idx_users_username ON users(username);
+CREATE INDEX IF NOT EXISTS idx_users_email ON users(email);
+CREATE UNIQUE INDEX IF NOT EXISTS idx_users_email_unique ON users(email) WHERE email IS NOT NULL AND email != '';
+
 CREATE TABLE IF NOT EXISTS games (
 	game_id TEXT PRIMARY KEY,
 	initial_fen TEXT NOT NULL,

internal/storage/storage.go

@@ -14,7 +14,7 @@ import (
 	_ "github.com/mattn/go-sqlite3"
 )
 
-// Store handles SQLite database operations with async writes
+// Store handles SQLite database operations with async writes for games and sync writes for auth
 type Store struct {
 	db           *sql.DB
 	path         string
@@ -70,6 +70,11 @@ func NewStore(dataSourceName string, devMode bool) (*Store, error) {
 	return s, nil
 }
 
+// IsHealthy returns the current health status
+func (s *Store) IsHealthy() bool {
+	return s.healthStatus.Load()
+}
+
 // writerLoop processes async write operations
 func (s *Store) writerLoop() {
 	defer s.wg.Done()
@@ -125,88 +130,6 @@ func (s *Store) executeWrite(fn func(*sql.Tx) error) {
 	}
 }
 
-// RecordNewGame asynchronously records a new game
-func (s *Store) RecordNewGame(record GameRecord) error {
-	if !s.healthStatus.Load() {
-		return nil // Silently drop if degraded
-	}
-
-	select {
-	case s.writeChan <- func(tx *sql.Tx) error {
-		query := `INSERT INTO games (
-			game_id, initial_fen, 
-			white_player_id, white_type, white_level, white_search_time,
-			black_player_id, black_type, black_level, black_search_time,
-			start_time_utc
-		) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
-
-		_, err := tx.Exec(query,
-			record.GameID, record.InitialFEN,
-			record.WhitePlayerID, record.WhiteType, record.WhiteLevel, record.WhiteSearchTime,
-			record.BlackPlayerID, record.BlackType, record.BlackLevel, record.BlackSearchTime,
-			record.StartTimeUTC,
-		)
-		return err
-	}:
-		return nil
-	default:
-		// Channel full, drop write
-		log.Printf("Storage write queue full, dropping game record")
-		return nil
-	}
-}
-
-// RecordMove asynchronously records a move
-func (s *Store) RecordMove(record MoveRecord) error {
-	if !s.healthStatus.Load() {
-		return nil // Silently drop if degraded
-	}
-
-	select {
-	case s.writeChan <- func(tx *sql.Tx) error {
-		query := `INSERT INTO moves (
-			game_id, move_number, move_uci, fen_after_move, player_color, move_time_utc
-		) VALUES (?, ?, ?, ?, ?, ?)`
-
-		_, err := tx.Exec(query,
-			record.GameID, record.MoveNumber, record.MoveUCI,
-			record.FENAfterMove, record.PlayerColor, record.MoveTimeUTC,
-		)
-		return err
-	}:
-		return nil
-	default:
-		// Channel full, drop write
-		log.Printf("Storage write queue full, dropping move record")
-		return nil
-	}
-}
-
-// DeleteUndoneMoves asynchronously deletes moves after undo
-func (s *Store) DeleteUndoneMoves(gameID string, afterMoveNumber int) error {
-	if !s.healthStatus.Load() {
-		return nil // Silently drop if degraded
-	}
-
-	select {
-	case s.writeChan <- func(tx *sql.Tx) error {
-		query := `DELETE FROM moves WHERE game_id = ? AND move_number > ?`
-		_, err := tx.Exec(query, gameID, afterMoveNumber)
-		return err
-	}:
-		return nil
-	default:
-		// Channel full, drop write
-		log.Printf("Storage write queue full, dropping undo operation")
-		return nil
-	}
-}
-
-// IsHealthy returns the current health status
-func (s *Store) IsHealthy() bool {
-	return s.healthStatus.Load()
-}
-
 // Close gracefully closes the database connection
 func (s *Store) Close() error {
 	// Signal writer to stop
@@ -260,57 +183,4 @@ func (s *Store) DeleteDB() error {
 	}
 
 	return nil
-}
-
-// QueryGames retrieves games with optional filtering
-func (s *Store) QueryGames(gameID, playerID string) ([]GameRecord, error) {
-	query := `SELECT 
-		game_id, initial_fen, 
-		white_player_id, white_type, white_level, white_search_time,
-		black_player_id, black_type, black_level, black_search_time,
-		start_time_utc
-	FROM games WHERE 1=1`
-
-	var args []interface{}
-
-	// Handle gameID filtering
-	if gameID != "" && gameID != "*" {
-		query += " AND game_id = ?"
-		args = append(args, gameID)
-	}
-
-	// Handle playerID filtering
-	if playerID != "" && playerID != "*" {
-		query += " AND (white_player_id = ? OR black_player_id = ?)"
-		args = append(args, playerID, playerID)
-	}
-
-	query += " ORDER BY start_time_utc DESC"
-
-	rows, err := s.db.Query(query, args...)
-	if err != nil {
-		return nil, fmt.Errorf("query failed: %w", err)
-	}
-	defer rows.Close()
-
-	var games []GameRecord
-	for rows.Next() {
-		var g GameRecord
-		err := rows.Scan(
-			&g.GameID, &g.InitialFEN,
-			&g.WhitePlayerID, &g.WhiteType, &g.WhiteLevel, &g.WhiteSearchTime,
-			&g.BlackPlayerID, &g.BlackType, &g.BlackLevel, &g.BlackSearchTime,
-			&g.StartTimeUTC,
-		)
-		if err != nil {
-			return nil, fmt.Errorf("scan failed: %w", err)
-		}
-		games = append(games, g)
-	}
-
-	if err := rows.Err(); err != nil {
-		return nil, fmt.Errorf("rows iteration failed: %w", err)
-	}
-
-	return games, nil
 }

internal/storage/user.go

@@ -0,0 +1,187 @@
+// FILE: internal/storage/user.go
+package storage
+
+import (
+	"database/sql"
+	"fmt"
+	"log"
+	"time"
+)
+
+// CreateUser creates user with transaction isolation to prevent race conditions
+func (s *Store) CreateUser(record UserRecord) error {
+	tx, err := s.db.Begin()
+	if err != nil {
+		return fmt.Errorf("failed to begin transaction: %w", err)
+	}
+	defer tx.Rollback()
+
+	// Check uniqueness within transaction
+	exists, err := s.userExists(tx, record.Username, record.Email)
+	if err != nil {
+		return err
+	}
+	if exists {
+		return fmt.Errorf("username or email already exists")
+	}
+
+	// Insert user
+	query := `INSERT INTO users (
+		user_id, username, email, password_hash, created_at
+	) VALUES (?, ?, ?, ?, ?)`
+
+	_, err = tx.Exec(query,
+		record.UserID, record.Username, record.Email,
+		record.PasswordHash, record.CreatedAt,
+	)
+	if err != nil {
+		return err
+	}
+
+	return tx.Commit()
+}
+
+// userExists verifies username/email uniqueness within a transaction
+func (s *Store) userExists(tx *sql.Tx, username, email string) (bool, error) {
+	var count int
+	query := `SELECT COUNT(*) FROM users WHERE username = ? COLLATE NOCASE`
+	args := []interface{}{username}
+
+	if email != "" {
+		query = `SELECT COUNT(*) FROM users WHERE username = ? COLLATE NOCASE OR email = ? COLLATE NOCASE`
+		args = append(args, email)
+	}
+
+	err := tx.QueryRow(query, args...).Scan(&count)
+	if err != nil {
+		return false, err
+	}
+	return count > 0, nil
+}
+
+// UpdateUserPassword updates user password hash
+func (s *Store) UpdateUserPassword(userID string, passwordHash string) error {
+	query := `UPDATE users SET password_hash = ? WHERE user_id = ?`
+	_, err := s.db.Exec(query, passwordHash, userID)
+	return err
+}
+
+// UpdateUserEmail updates user email
+func (s *Store) UpdateUserEmail(userID string, email string) error {
+	query := `UPDATE users SET email = ? WHERE user_id = ?`
+	_, err := s.db.Exec(query, email, userID)
+	return err
+}
+
+// UpdateUserUsername updates username
+func (s *Store) UpdateUserUsername(userID string, username string) error {
+	query := `UPDATE users SET username = ? WHERE user_id = ?`
+	_, err := s.db.Exec(query, username, userID)
+	return err
+}
+
+// GetAllUsers retrieves all users
+func (s *Store) GetAllUsers() ([]UserRecord, error) {
+	query := `SELECT user_id, username, email, password_hash, created_at, last_login_at
+		FROM users ORDER BY created_at DESC`
+
+	rows, err := s.db.Query(query)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+
+	var users []UserRecord
+	for rows.Next() {
+		var user UserRecord
+		err := rows.Scan(
+			&user.UserID, &user.Username, &user.Email,
+			&user.PasswordHash, &user.CreatedAt, &user.LastLoginAt,
+		)
+		if err != nil {
+			return nil, err
+		}
+		users = append(users, user)
+	}
+
+	return users, rows.Err()
+}
+
+// UpdateUserLastLoginSync updates user last login time
+func (s *Store) UpdateUserLastLoginSync(userID string, loginTime time.Time) error {
+	query := `UPDATE users SET last_login_at = ? WHERE user_id = ?`
+
+	_, err := s.db.Exec(query, loginTime, userID)
+	if err != nil {
+		return fmt.Errorf("failed to update last login for user %s: %w", userID, err)
+	}
+
+	return nil
+}
+
+// GetUserByUsername retrieves user by username with case-insensitive matching
+func (s *Store) GetUserByUsername(username string) (*UserRecord, error) {
+	var user UserRecord
+	query := `SELECT user_id, username, email, password_hash, created_at, last_login_at
+		FROM users WHERE username = ? COLLATE NOCASE`
+
+	err := s.db.QueryRow(query, username).Scan(
+		&user.UserID, &user.Username, &user.Email,
+		&user.PasswordHash, &user.CreatedAt, &user.LastLoginAt,
+	)
+	if err != nil {
+		return nil, err
+	}
+	return &user, nil
+}
+
+// GetUserByEmail retrieves user by email with case-insensitive matching
+func (s *Store) GetUserByEmail(email string) (*UserRecord, error) {
+	var user UserRecord
+	query := `SELECT user_id, username, email, password_hash, created_at, last_login_at
+		FROM users WHERE email = ? COLLATE NOCASE`
+
+	err := s.db.QueryRow(query, email).Scan(
+		&user.UserID, &user.Username, &user.Email,
+		&user.PasswordHash, &user.CreatedAt, &user.LastLoginAt,
+	)
+	if err != nil {
+		return nil, err
+	}
+	return &user, nil
+}
+
+// GetUserByID retrieves user by unique user ID
+func (s *Store) GetUserByID(userID string) (*UserRecord, error) {
+	var user UserRecord
+	query := `SELECT user_id, username, email, password_hash, created_at, last_login_at
+		FROM users WHERE user_id = ?`
+
+	err := s.db.QueryRow(query, userID).Scan(
+		&user.UserID, &user.Username, &user.Email,
+		&user.PasswordHash, &user.CreatedAt, &user.LastLoginAt,
+	)
+	if err != nil {
+		return nil, err
+	}
+	return &user, nil
+}
+
+// DeleteUser removes a user from the database
+func (s *Store) DeleteUser(userID string) error {
+	if !s.healthStatus.Load() {
+		return nil
+	}
+
+	select {
+	case s.writeChan <- func(tx *sql.Tx) error {
+		query := `DELETE FROM users WHERE user_id = ?`
+		_, err := tx.Exec(query, userID)
+		return err
+	}:
+		return nil
+	default:
+		log.Printf("Storage write queue full, dropping user deletion")
+		return nil
+	}
+}