OwnCord/Server/db/pgdbgen/sessions.sql.go

//go:build postgres

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

package pgdbgen

import (
	"context"

	"github.com/jackc/pgx/v5/pgtype"
)

const deleteExpiredSessions = `-- name: DeleteExpiredSessions :exec
DELETE FROM sessions WHERE expires_at < NOW()
`

// Use native timestamp comparison instead of sqlite's strftime trick.
func (q *Queries) DeleteExpiredSessions(ctx context.Context) error {
	_, err := q.db.Exec(ctx, deleteExpiredSessions)
	return err
}

const deleteOtherSessions = `-- name: DeleteOtherSessions :execrows
DELETE FROM sessions WHERE user_id = $1 AND id != $2
`

type DeleteOtherSessionsParams struct {
	UserID int64 `json:"userId"`
	ID     int64 `json:"id"`
}

func (q *Queries) DeleteOtherSessions(ctx context.Context, arg DeleteOtherSessionsParams) (int64, error) {
	result, err := q.db.Exec(ctx, deleteOtherSessions, arg.UserID, arg.ID)
	if err != nil {
		return 0, err
	}
	return result.RowsAffected(), nil
}

const deleteSessionByID = `-- name: DeleteSessionByID :exec
DELETE FROM sessions WHERE id = $1 AND user_id = $2
`

type DeleteSessionByIDParams struct {
	ID     int64 `json:"id"`
	UserID int64 `json:"userId"`
}

func (q *Queries) DeleteSessionByID(ctx context.Context, arg DeleteSessionByIDParams) error {
	_, err := q.db.Exec(ctx, deleteSessionByID, arg.ID, arg.UserID)
	return err
}

const deleteSessionByToken = `-- name: DeleteSessionByToken :exec
DELETE FROM sessions WHERE token = $1
`

func (q *Queries) DeleteSessionByToken(ctx context.Context, token string) error {
	_, err := q.db.Exec(ctx, deleteSessionByToken, token)
	return err
}

const evictOldestSessions = `-- name: EvictOldestSessions :exec
DELETE FROM sessions WHERE id IN (
    SELECT s2.id FROM sessions AS s2 WHERE s2.user_id = $1
    ORDER BY s2.created_at DESC
    OFFSET $2
)
`

type EvictOldestSessionsParams struct {
	UserID int64 `json:"userId"`
	Offset int32 `json:"offset"`
}

// Delete all but the N most recent sessions for a user. Postgres replaces
// sqlite's `LIMIT -1 OFFSET ?` with `OFFSET $2`.
func (q *Queries) EvictOldestSessions(ctx context.Context, arg EvictOldestSessionsParams) error {
	_, err := q.db.Exec(ctx, evictOldestSessions, arg.UserID, arg.Offset)
	return err
}

const getSessionByTokenHash = `-- name: GetSessionByTokenHash :one
SELECT id, user_id, token, device, ip_address, created_at, last_used, expires_at
FROM sessions WHERE token = $1
`

func (q *Queries) GetSessionByTokenHash(ctx context.Context, token string) (Session, error) {
	row := q.db.QueryRow(ctx, getSessionByTokenHash, token)
	var i Session
	err := row.Scan(
		&i.ID,
		&i.UserID,
		&i.Token,
		&i.Device,
		&i.IpAddress,
		&i.CreatedAt,
		&i.LastUsed,
		&i.ExpiresAt,
	)
	return i, err
}

const getSessionWithBanStatus = `-- name: GetSessionWithBanStatus :one
SELECT s.id, s.user_id, s.token, s.device, s.ip_address,
       s.created_at, s.last_used, s.expires_at,
       u.banned, u.ban_reason, u.ban_expires
FROM sessions s
JOIN users u ON s.user_id = u.id
WHERE s.token = $1
`

type GetSessionWithBanStatusRow struct {
	ID         int64              `json:"id"`
	UserID     int64              `json:"userId"`
	Token      string             `json:"token"`
	Device     *string            `json:"device"`
	IpAddress  *string            `json:"ipAddress"`
	CreatedAt  pgtype.Timestamptz `json:"createdAt"`
	LastUsed   pgtype.Timestamptz `json:"lastUsed"`
	ExpiresAt  pgtype.Timestamptz `json:"expiresAt"`
	Banned     bool               `json:"banned"`
	BanReason  *string            `json:"banReason"`
	BanExpires pgtype.Timestamptz `json:"banExpires"`
}

func (q *Queries) GetSessionWithBanStatus(ctx context.Context, token string) (GetSessionWithBanStatusRow, error) {
	row := q.db.QueryRow(ctx, getSessionWithBanStatus, token)
	var i GetSessionWithBanStatusRow
	err := row.Scan(
		&i.ID,
		&i.UserID,
		&i.Token,
		&i.Device,
		&i.IpAddress,
		&i.CreatedAt,
		&i.LastUsed,
		&i.ExpiresAt,
		&i.Banned,
		&i.BanReason,
		&i.BanExpires,
	)
	return i, err
}

const insertSession = `-- name: InsertSession :one

INSERT INTO sessions (user_id, token, device, ip_address, expires_at)
VALUES ($1, $2, $3, $4, $5)
RETURNING id
`

type InsertSessionParams struct {
	UserID    int64              `json:"userId"`
	Token     string             `json:"token"`
	Device    *string            `json:"device"`
	IpAddress *string            `json:"ipAddress"`
	ExpiresAt pgtype.Timestamptz `json:"expiresAt"`
}

// PostgreSQL variants of the sqlite sessions queries.
func (q *Queries) InsertSession(ctx context.Context, arg InsertSessionParams) (int64, error) {
	row := q.db.QueryRow(ctx, insertSession,
		arg.UserID,
		arg.Token,
		arg.Device,
		arg.IpAddress,
		arg.ExpiresAt,
	)
	var id int64
	err := row.Scan(&id)
	return id, err
}

const listUserSessions = `-- name: ListUserSessions :many
SELECT id, user_id, token, device, ip_address, created_at, last_used, expires_at
FROM sessions
WHERE user_id = $1
ORDER BY created_at DESC
`

func (q *Queries) ListUserSessions(ctx context.Context, userID int64) ([]Session, error) {
	rows, err := q.db.Query(ctx, listUserSessions, userID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	items := []Session{}
	for rows.Next() {
		var i Session
		if err := rows.Scan(
			&i.ID,
			&i.UserID,
			&i.Token,
			&i.Device,
			&i.IpAddress,
			&i.CreatedAt,
			&i.LastUsed,
			&i.ExpiresAt,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const touchSession = `-- name: TouchSession :exec
UPDATE sessions SET last_used = NOW() WHERE token = $1
`

func (q *Queries) TouchSession(ctx context.Context, token string) error {
	_, err := q.db.Exec(ctx, touchSession, token)
	return err
}