// Code generated by sqlc. DO NOT EDIT.
// versions:
//   sqlc v1.31.1
// source: queries.sql

package sqlc

import (
	"context"

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

const createAuthUser = `-- name: CreateAuthUser :one
INSERT INTO auth.users (
  id,
  email,
  encrypted_password,
  raw_user_meta_data,
  created_at,
  updated_at
) VALUES (
  $1,
  $2,
  $3,
  jsonb_build_object('display_name', $4::text),
  now(),
  now()
)
RETURNING id
`

type CreateAuthUserParams struct {
	ID                uuid.UUID `db:"id"`
	Email             string    `db:"email"`
	EncryptedPassword string    `db:"encrypted_password"`
	DisplayName       string    `db:"display_name"`
}

func (q *Queries) CreateAuthUser(ctx context.Context, arg CreateAuthUserParams) (uuid.UUID, error) {
	row := q.db.QueryRow(ctx, createAuthUser,
		arg.ID,
		arg.Email,
		arg.EncryptedPassword,
		arg.DisplayName,
	)
	var id uuid.UUID
	err := row.Scan(&id)
	return id, err
}

const createSession = `-- name: CreateSession :exec
INSERT INTO auth.sessions (
  id,
  session_token,
  user_id,
  created_at,
  updated_at,
  expires_at
) VALUES (
  $1,
  $2,
  $3,
  now(),
  now(),
  $4
)
`

type CreateSessionParams struct {
	ID           uuid.UUID          `db:"id"`
	SessionToken string             `db:"session_token"`
	UserID       uuid.UUID          `db:"user_id"`
	ExpiresAt    pgtype.Timestamptz `db:"expires_at"`
}

func (q *Queries) CreateSession(ctx context.Context, arg CreateSessionParams) error {
	_, err := q.db.Exec(ctx, createSession,
		arg.ID,
		arg.SessionToken,
		arg.UserID,
		arg.ExpiresAt,
	)
	return err
}

const deleteSessionByToken = `-- name: DeleteSessionByToken :execrows
DELETE FROM auth.sessions
WHERE session_token = $1
`

func (q *Queries) DeleteSessionByToken(ctx context.Context, sessionToken string) (int64, error) {
	result, err := q.db.Exec(ctx, deleteSessionByToken, sessionToken)
	if err != nil {
		return 0, err
	}
	return result.RowsAffected(), nil
}

const getAuthUserByEmail = `-- name: GetAuthUserByEmail :one
SELECT id, email, encrypted_password, created_at, updated_at
FROM auth.users
WHERE email = $1
LIMIT 1
`

type GetAuthUserByEmailRow struct {
	ID                uuid.UUID          `db:"id"`
	Email             string             `db:"email"`
	EncryptedPassword string             `db:"encrypted_password"`
	CreatedAt         pgtype.Timestamptz `db:"created_at"`
	UpdatedAt         pgtype.Timestamptz `db:"updated_at"`
}

func (q *Queries) GetAuthUserByEmail(ctx context.Context, email string) (GetAuthUserByEmailRow, error) {
	row := q.db.QueryRow(ctx, getAuthUserByEmail, email)
	var i GetAuthUserByEmailRow
	err := row.Scan(
		&i.ID,
		&i.Email,
		&i.EncryptedPassword,
		&i.CreatedAt,
		&i.UpdatedAt,
	)
	return i, err
}

const getPublicUserByID = `-- name: GetPublicUserByID :one
SELECT id, email, created_at, updated_at, display_name
FROM public.users
WHERE id = $1
LIMIT 1
`

func (q *Queries) GetPublicUserByID(ctx context.Context, id uuid.UUID) (User, error) {
	row := q.db.QueryRow(ctx, getPublicUserByID, id)
	var i User
	err := row.Scan(
		&i.ID,
		&i.Email,
		&i.CreatedAt,
		&i.UpdatedAt,
		&i.DisplayName,
	)
	return i, err
}

const getSessionByToken = `-- name: GetSessionByToken :one
SELECT id, session_token, user_id, created_at, updated_at, expires_at
FROM auth.sessions
WHERE session_token = $1
LIMIT 1
`

func (q *Queries) GetSessionByToken(ctx context.Context, sessionToken string) (AuthSession, error) {
	row := q.db.QueryRow(ctx, getSessionByToken, sessionToken)
	var i AuthSession
	err := row.Scan(
		&i.ID,
		&i.SessionToken,
		&i.UserID,
		&i.CreatedAt,
		&i.UpdatedAt,
		&i.ExpiresAt,
	)
	return i, err
}