softplayer-backend/internal/repository/tokens.go

package repository

import (
	"context"
	"database/sql"
	"errors"
	"time"
)

type TokenData struct {
	UUID        string
	Decsription string
	TokenHash   string
	UserID      string
	CreatedAt   time.Time
	GeneratedAt time.Time
	ExpiresAt   time.Time
	RevokedAt   time.Time
	LastUsedAt  time.Time
	Scope       string
}

// CreateToken adds a new token to a database
func CreateToken(ctx context.Context, db *sql.DB, data *TokenData) error {
	query := `
	INSERT INTO tokens 
	(uuid, description, token_hash, user_id, scopes, created_at, generated_at, expires_at) 
	VALUES 
	($1, $2, $3, $4, $5, $6, $7, $8);`
	if _, err := db.QueryContext(
		ctx,
		query,
		data.UUID,
		data.Decsription,
		data.TokenHash,
		data.UserID,
		data.Scope,
		data.CreatedAt,
		data.GeneratedAt,
		data.ExpiresAt,
	); err != nil {
		return err
	}
	return nil
}

// UpdateToken updates token description and scope
func UpdateToken(ctx context.Context, db *sql.DB, data *TokenData) error {
	query := "UPDATE tokens SET description = $1, scopes = $2 WHERE uuid = $3;"
	if _, err := db.QueryContext(ctx, query, data.Decsription, data.Scope, data.UUID); err != nil {
		return err
	}
	return nil
}

func GetToken(ctx context.Context, db *sql.DB, tokenID, userID string) (*TokenData, error) {
	query := `
	SELECT 
		uuid, description, generated_at, expires_at,
		last_used_at, revoked_at, created_at, scopes
	FROM tokens
	WHERE uuid = $1 AND user_id = $2;`

	var generatedAt sql.NullTime
	var expiresAt sql.NullTime
	var revokedAt sql.NullTime
	var lastUsedAt sql.NullTime
	var createdAt sql.NullTime

	result := &TokenData{}

	if err := db.QueryRowContext(ctx, query, tokenID, userID).Scan(
		&result.UUID,
		&result.Decsription,
		&generatedAt,
		&expiresAt,
		&lastUsedAt,
		&revokedAt,
		&createdAt,
		&result.Scope,
	); err != nil {
		if errors.Is(err, sql.ErrNoRows) {
			return nil, ErrNotFound
		}
		return nil, err
	}
	result.GeneratedAt = generatedAt.Time
	result.ExpiresAt = expiresAt.Time
	result.RevokedAt = revokedAt.Time
	result.LastUsedAt = lastUsedAt.Time
	result.CreatedAt = createdAt.Time

	return result, nil
}

// RevokeToken sets revoked_at for a token by id
func RevokeToken(ctx context.Context, db *sql.DB, tokenID string, revokedAt time.Time) error {
	query := "UPDATE tokens SET revoked_at = $1 WHERE uuid = $2;"
	if _, err := db.Query(query, revokedAt, tokenID); err != nil {
		return err
	}
	return nil
}

// RegenerateToken sets a new token hash and updates the generated at
func RegenerateToken(ctx context.Context, db *sql.DB, tokenID, hash string, generatedAt time.Time) error {
	query := `
	UPDATE tokens 
	SET 
		token_hash = $1,
		generated_at = $2,
		expires_at = NOW() + (expires_at - generated_at)
	WHERE uuid = $3;`
	if _, err := db.Query(query, hash, generatedAt, tokenID); err != nil {
		return err
	}
	return nil
}

func ListTokensByUserID(ctx context.Context, db *sql.DB, userID string) ([]TokenData, error) {
	query := `
		SELECT uuid, description, generated_at, expires_at, revoked_at, last_used_at, created_at, scopes
		FROM tokens
		WHERE user_id = $1`
	rows, err := db.QueryContext(ctx, query, userID)
	if err != nil {
		if errors.Is(err, sql.ErrNoRows) {
			return nil, ErrNotFound
		}
		return nil, err
	}

	defer rows.Close()

	if err := rows.Err(); err != nil {
		return nil, err
	}

	result := []TokenData{}
	for rows.Next() {
		var t TokenData

		var generatedAt sql.NullTime
		var expiresAt sql.NullTime
		var revokedAt sql.NullTime
		var lastUsedAt sql.NullTime
		var createdAt sql.NullTime

		err := rows.Scan(
			&t.UUID,
			&t.Decsription,
			&generatedAt,
			&expiresAt,
			&revokedAt,
			&lastUsedAt,
			&createdAt,
			&t.Scope,
		)

		t.GeneratedAt = generatedAt.Time
		t.ExpiresAt = expiresAt.Time
		t.RevokedAt = revokedAt.Time
		t.LastUsedAt = lastUsedAt.Time
		t.CreatedAt = createdAt.Time

		if err != nil {
			return nil, err
		}

		result = append(result, t)
	}

	return result, nil
}

// GetTokenDataBySHA returns a token data for a token found by its hash
func GetTokenDataBySHA(ctx context.Context, db *sql.DB, sha string) (*TokenData, error) {
	query := `
	SELECT user_id, scopes, expires_at, revoked_at
	FROM tokens
	WHERE token_hash = $1`

	result := &TokenData{}
	var expiresAt sql.NullTime
	var revokedAt sql.NullTime

	if err := db.QueryRowContext(ctx, query, sha).Scan(
		&result.UserID,
		&result.Scope,
		&expiresAt,
		&revokedAt,
	); err != nil {
		if errors.Is(err, sql.ErrNoRows) {
			return nil, ErrNotFound
		}
		return nil, err
	}

	result.RevokedAt = revokedAt.Time
	result.ExpiresAt = expiresAt.Time
	return result, nil
}