xtablo-source/go-backend/internal/db/sqlc/queries.sql.go

// 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 createTablo = `-- name: CreateTablo :one
INSERT INTO public.tablos (
  id,
  owner_id,
  name,
  status,
  created_at,
  updated_at
) VALUES (
  $1,
  $2,
  $3,
  $4,
  now(),
  now()
)
RETURNING id, owner_id, name, status, created_at, updated_at, deleted_at
`

type CreateTabloParams struct {
	ID      uuid.UUID `db:"id"`
	OwnerID uuid.UUID `db:"owner_id"`
	Name    string    `db:"name"`
	Status  string    `db:"status"`
}

func (q *Queries) CreateTablo(ctx context.Context, arg CreateTabloParams) (Tablo, error) {
	row := q.db.QueryRow(ctx, createTablo,
		arg.ID,
		arg.OwnerID,
		arg.Name,
		arg.Status,
	)
	var i Tablo
	err := row.Scan(
		&i.ID,
		&i.OwnerID,
		&i.Name,
		&i.Status,
		&i.CreatedAt,
		&i.UpdatedAt,
		&i.DeletedAt,
	)
	return i, 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
}

const listTablos = `-- name: ListTablos :many
SELECT id, owner_id, name, status, created_at, updated_at, deleted_at
FROM public.tablos
WHERE owner_id = $1
  AND deleted_at IS NULL
  AND (
    $2::text IS NULL OR status = $2::text
  )
  AND (
    $3::text IS NULL OR name ILIKE '%' || $3::text || '%'
  )
ORDER BY created_at DESC
`

type ListTablosParams struct {
	OwnerID uuid.UUID   `db:"owner_id"`
	Status  pgtype.Text `db:"status"`
	Query   pgtype.Text `db:"query"`
}

func (q *Queries) ListTablos(ctx context.Context, arg ListTablosParams) ([]Tablo, error) {
	rows, err := q.db.Query(ctx, listTablos, arg.OwnerID, arg.Status, arg.Query)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []Tablo
	for rows.Next() {
		var i Tablo
		if err := rows.Scan(
			&i.ID,
			&i.OwnerID,
			&i.Name,
			&i.Status,
			&i.CreatedAt,
			&i.UpdatedAt,
			&i.DeletedAt,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const softDeleteTablo = `-- name: SoftDeleteTablo :execrows
UPDATE public.tablos
SET deleted_at = now(), updated_at = now()
WHERE id = $1
  AND owner_id = $2
  AND deleted_at IS NULL
`

type SoftDeleteTabloParams struct {
	ID      uuid.UUID `db:"id"`
	OwnerID uuid.UUID `db:"owner_id"`
}

func (q *Queries) SoftDeleteTablo(ctx context.Context, arg SoftDeleteTabloParams) (int64, error) {
	result, err := q.db.Exec(ctx, softDeleteTablo, arg.ID, arg.OwnerID)
	if err != nil {
		return 0, err
	}
	return result.RowsAffected(), nil
}