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"
	"github.com/jackc/pgx/v5/pgtype"
)

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      pgtype.Text `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
  AND is_active = TRUE
`

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 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
}