hspguard/internal/repository/user_sessions.sql.go

// Code generated by sqlc. DO NOT EDIT.
// versions:
//   sqlc v1.29.0
// source: user_sessions.sql

package repository

import (
	"context"
	"time"

	"github.com/google/uuid"
)

const createUserSession = `-- name: CreateUserSession :one
INSERT INTO user_sessions (
    user_id, session_type, issued_at, expires_at, last_active,
    ip_address, user_agent, access_token_id, refresh_token_id,
    device_info, is_active
) VALUES (
    $1, $2, NOW(), $3, $4,
    $5, $6, $7, $8,
    $9, TRUE
)
RETURNING id, user_id, session_type, issued_at, expires_at, last_active, ip_address, user_agent, access_token_id, refresh_token_id, device_info, is_active, revoked_at
`

type CreateUserSessionParams struct {
	UserID         uuid.UUID  `json:"user_id"`
	SessionType    string     `json:"session_type"`
	ExpiresAt      *time.Time `json:"expires_at"`
	LastActive     *time.Time `json:"last_active"`
	IpAddress      *string    `json:"ip_address"`
	UserAgent      *string    `json:"user_agent"`
	AccessTokenID  *uuid.UUID `json:"access_token_id"`
	RefreshTokenID *uuid.UUID `json:"refresh_token_id"`
	DeviceInfo     []byte     `json:"device_info"`
}

func (q *Queries) CreateUserSession(ctx context.Context, arg CreateUserSessionParams) (UserSession, error) {
	row := q.db.QueryRow(ctx, createUserSession,
		arg.UserID,
		arg.SessionType,
		arg.ExpiresAt,
		arg.LastActive,
		arg.IpAddress,
		arg.UserAgent,
		arg.AccessTokenID,
		arg.RefreshTokenID,
		arg.DeviceInfo,
	)
	var i UserSession
	err := row.Scan(
		&i.ID,
		&i.UserID,
		&i.SessionType,
		&i.IssuedAt,
		&i.ExpiresAt,
		&i.LastActive,
		&i.IpAddress,
		&i.UserAgent,
		&i.AccessTokenID,
		&i.RefreshTokenID,
		&i.DeviceInfo,
		&i.IsActive,
		&i.RevokedAt,
	)
	return i, err
}

const getUserSessionByAccessJTI = `-- name: GetUserSessionByAccessJTI :one
SELECT id, user_id, session_type, issued_at, expires_at, last_active, ip_address, user_agent, access_token_id, refresh_token_id, device_info, is_active, revoked_at FROM user_sessions
WHERE access_token_id = $1
  AND is_active = TRUE
`

func (q *Queries) GetUserSessionByAccessJTI(ctx context.Context, accessTokenID *uuid.UUID) (UserSession, error) {
	row := q.db.QueryRow(ctx, getUserSessionByAccessJTI, accessTokenID)
	var i UserSession
	err := row.Scan(
		&i.ID,
		&i.UserID,
		&i.SessionType,
		&i.IssuedAt,
		&i.ExpiresAt,
		&i.LastActive,
		&i.IpAddress,
		&i.UserAgent,
		&i.AccessTokenID,
		&i.RefreshTokenID,
		&i.DeviceInfo,
		&i.IsActive,
		&i.RevokedAt,
	)
	return i, err
}

const getUserSessionByRefreshJTI = `-- name: GetUserSessionByRefreshJTI :one
SELECT id, user_id, session_type, issued_at, expires_at, last_active, ip_address, user_agent, access_token_id, refresh_token_id, device_info, is_active, revoked_at FROM user_sessions
WHERE refresh_token_id = $1
`

func (q *Queries) GetUserSessionByRefreshJTI(ctx context.Context, refreshTokenID *uuid.UUID) (UserSession, error) {
	row := q.db.QueryRow(ctx, getUserSessionByRefreshJTI, refreshTokenID)
	var i UserSession
	err := row.Scan(
		&i.ID,
		&i.UserID,
		&i.SessionType,
		&i.IssuedAt,
		&i.ExpiresAt,
		&i.LastActive,
		&i.IpAddress,
		&i.UserAgent,
		&i.AccessTokenID,
		&i.RefreshTokenID,
		&i.DeviceInfo,
		&i.IsActive,
		&i.RevokedAt,
	)
	return i, err
}

const getUserSessions = `-- name: GetUserSessions :many
SELECT session.id, session.user_id, session.session_type, session.issued_at, session.expires_at, session.last_active, session.ip_address, session.user_agent, session.access_token_id, session.refresh_token_id, session.device_info, session.is_active, session.revoked_at, u.id, u.email, u.full_name, u.password_hash, u.is_admin, u.created_at, u.updated_at, u.last_login, u.phone_number, u.profile_picture, u.created_by, u.email_verified, u.avatar_verified, u.verified
FROM user_sessions AS session
JOIN users AS u ON u.id = session.user_id
ORDER BY session.issued_at DESC
LIMIT $1 OFFSET $2
`

type GetUserSessionsParams struct {
	Limit  int32 `json:"limit"`
	Offset int32 `json:"offset"`
}

type GetUserSessionsRow struct {
	UserSession UserSession `json:"user_session"`
	User        User        `json:"user"`
}

func (q *Queries) GetUserSessions(ctx context.Context, arg GetUserSessionsParams) ([]GetUserSessionsRow, error) {
	rows, err := q.db.Query(ctx, getUserSessions, arg.Limit, arg.Offset)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []GetUserSessionsRow
	for rows.Next() {
		var i GetUserSessionsRow
		if err := rows.Scan(
			&i.UserSession.ID,
			&i.UserSession.UserID,
			&i.UserSession.SessionType,
			&i.UserSession.IssuedAt,
			&i.UserSession.ExpiresAt,
			&i.UserSession.LastActive,
			&i.UserSession.IpAddress,
			&i.UserSession.UserAgent,
			&i.UserSession.AccessTokenID,
			&i.UserSession.RefreshTokenID,
			&i.UserSession.DeviceInfo,
			&i.UserSession.IsActive,
			&i.UserSession.RevokedAt,
			&i.User.ID,
			&i.User.Email,
			&i.User.FullName,
			&i.User.PasswordHash,
			&i.User.IsAdmin,
			&i.User.CreatedAt,
			&i.User.UpdatedAt,
			&i.User.LastLogin,
			&i.User.PhoneNumber,
			&i.User.ProfilePicture,
			&i.User.CreatedBy,
			&i.User.EmailVerified,
			&i.User.AvatarVerified,
			&i.User.Verified,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const getUserSessionsCount = `-- name: GetUserSessionsCount :one
SELECT COUNT(*) FROM user_sessions
`

func (q *Queries) GetUserSessionsCount(ctx context.Context) (int64, error) {
	row := q.db.QueryRow(ctx, getUserSessionsCount)
	var count int64
	err := row.Scan(&count)
	return count, err
}

const listActiveUserSessions = `-- name: ListActiveUserSessions :many
SELECT id, user_id, session_type, issued_at, expires_at, last_active, ip_address, user_agent, access_token_id, refresh_token_id, device_info, is_active, revoked_at FROM user_sessions
WHERE user_id = $1
  AND is_active = TRUE
ORDER BY issued_at DESC
`

func (q *Queries) ListActiveUserSessions(ctx context.Context, userID uuid.UUID) ([]UserSession, error) {
	rows, err := q.db.Query(ctx, listActiveUserSessions, userID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []UserSession
	for rows.Next() {
		var i UserSession
		if err := rows.Scan(
			&i.ID,
			&i.UserID,
			&i.SessionType,
			&i.IssuedAt,
			&i.ExpiresAt,
			&i.LastActive,
			&i.IpAddress,
			&i.UserAgent,
			&i.AccessTokenID,
			&i.RefreshTokenID,
			&i.DeviceInfo,
			&i.IsActive,
			&i.RevokedAt,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const listAllSessions = `-- name: ListAllSessions :many
SELECT id, user_id, session_type, issued_at, expires_at, last_active, ip_address, user_agent, access_token_id, refresh_token_id, device_info, is_active, revoked_at FROM user_sessions
ORDER BY issued_at DESC
LIMIT $1 OFFSET $2
`

type ListAllSessionsParams struct {
	Limit  int32 `json:"limit"`
	Offset int32 `json:"offset"`
}

func (q *Queries) ListAllSessions(ctx context.Context, arg ListAllSessionsParams) ([]UserSession, error) {
	rows, err := q.db.Query(ctx, listAllSessions, arg.Limit, arg.Offset)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []UserSession
	for rows.Next() {
		var i UserSession
		if err := rows.Scan(
			&i.ID,
			&i.UserID,
			&i.SessionType,
			&i.IssuedAt,
			&i.ExpiresAt,
			&i.LastActive,
			&i.IpAddress,
			&i.UserAgent,
			&i.AccessTokenID,
			&i.RefreshTokenID,
			&i.DeviceInfo,
			&i.IsActive,
			&i.RevokedAt,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const revokeUserSession = `-- name: RevokeUserSession :exec
UPDATE user_sessions
SET is_active = FALSE,
    revoked_at = NOW()
WHERE id = $1
  AND is_active = TRUE
`

func (q *Queries) RevokeUserSession(ctx context.Context, id uuid.UUID) error {
	_, err := q.db.Exec(ctx, revokeUserSession, id)
	return err
}

const updateSessionLastActive = `-- name: UpdateSessionLastActive :exec
UPDATE user_sessions
SET last_active = NOW()
WHERE id = $1
  AND is_active = TRUE
`

func (q *Queries) UpdateSessionLastActive(ctx context.Context, id uuid.UUID) error {
	_, err := q.db.Exec(ctx, updateSessionLastActive, id)
	return err
}

const updateSessionTokens = `-- name: UpdateSessionTokens :exec
UPDATE user_sessions
SET access_token_id = $2, refresh_token_id = $3, expires_at = $4
WHERE id = $1
  AND is_active = TRUE
`

type UpdateSessionTokensParams struct {
	ID             uuid.UUID  `json:"id"`
	AccessTokenID  *uuid.UUID `json:"access_token_id"`
	RefreshTokenID *uuid.UUID `json:"refresh_token_id"`
	ExpiresAt      *time.Time `json:"expires_at"`
}

func (q *Queries) UpdateSessionTokens(ctx context.Context, arg UpdateSessionTokensParams) error {
	_, err := q.db.Exec(ctx, updateSessionTokens,
		arg.ID,
		arg.AccessTokenID,
		arg.RefreshTokenID,
		arg.ExpiresAt,
	)
	return err
}