Containr/app/backend/internal/database/sqlcdb/domains.sql.go

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

package sqlcdb

import (
	"context"
	"database/sql"
	"time"

	"github.com/google/uuid"
)

const clearServiceDomainDefault = `-- name: ClearServiceDomainDefault :exec
UPDATE service_domains SET is_default = false WHERE service_id = $1
`

func (q *Queries) ClearServiceDomainDefault(ctx context.Context, serviceID uuid.UUID) error {
	_, err := q.db.ExecContext(ctx, clearServiceDomainDefault, serviceID)
	return err
}

const countServiceDomains = `-- name: CountServiceDomains :one
SELECT COUNT(*) FROM service_domains WHERE service_id = $1
`

func (q *Queries) CountServiceDomains(ctx context.Context, serviceID uuid.UUID) (int64, error) {
	row := q.db.QueryRowContext(ctx, countServiceDomains, serviceID)
	var count int64
	err := row.Scan(&count)
	return count, err
}

const createServiceDomain = `-- name: CreateServiceDomain :one
INSERT INTO service_domains (service_id, domain, is_default)
VALUES ($1, $2, $3)
RETURNING id, service_id, domain, is_default, cert_type, cert_status, created_at
`

type CreateServiceDomainParams struct {
	ServiceID uuid.UUID `json:"service_id"`
	Domain    string    `json:"domain"`
	IsDefault bool      `json:"is_default"`
}

type CreateServiceDomainRow struct {
	ID         uuid.UUID `json:"id"`
	ServiceID  uuid.UUID `json:"service_id"`
	Domain     string    `json:"domain"`
	IsDefault  bool      `json:"is_default"`
	CertType   string    `json:"cert_type"`
	CertStatus string    `json:"cert_status"`
	CreatedAt  time.Time `json:"created_at"`
}

func (q *Queries) CreateServiceDomain(ctx context.Context, arg CreateServiceDomainParams) (CreateServiceDomainRow, error) {
	row := q.db.QueryRowContext(ctx, createServiceDomain, arg.ServiceID, arg.Domain, arg.IsDefault)
	var i CreateServiceDomainRow
	err := row.Scan(
		&i.ID,
		&i.ServiceID,
		&i.Domain,
		&i.IsDefault,
		&i.CertType,
		&i.CertStatus,
		&i.CreatedAt,
	)
	return i, err
}

const deleteServiceDomain = `-- name: DeleteServiceDomain :execrows
DELETE FROM service_domains WHERE id = $1 AND service_id = $2
`

type DeleteServiceDomainParams struct {
	ID        uuid.UUID `json:"id"`
	ServiceID uuid.UUID `json:"service_id"`
}

func (q *Queries) DeleteServiceDomain(ctx context.Context, arg DeleteServiceDomainParams) (int64, error) {
	result, err := q.db.ExecContext(ctx, deleteServiceDomain, arg.ID, arg.ServiceID)
	if err != nil {
		return 0, err
	}
	return result.RowsAffected()
}

const getServiceAccess = `-- name: GetServiceAccess :one
SELECT maintenance_mode, basic_auth_users FROM services WHERE id = $1
`

type GetServiceAccessRow struct {
	MaintenanceMode bool   `json:"maintenance_mode"`
	BasicAuthUsers  string `json:"basic_auth_users"`
}

func (q *Queries) GetServiceAccess(ctx context.Context, id uuid.UUID) (GetServiceAccessRow, error) {
	row := q.db.QueryRowContext(ctx, getServiceAccess, id)
	var i GetServiceAccessRow
	err := row.Scan(&i.MaintenanceMode, &i.BasicAuthUsers)
	return i, err
}

const getServiceDomainDefault = `-- name: GetServiceDomainDefault :one
SELECT domain FROM service_domains WHERE service_id = $1 AND is_default
`

func (q *Queries) GetServiceDomainDefault(ctx context.Context, serviceID uuid.UUID) (string, error) {
	row := q.db.QueryRowContext(ctx, getServiceDomainDefault, serviceID)
	var domain string
	err := row.Scan(&domain)
	return domain, err
}

const getServiceDomainFirst = `-- name: GetServiceDomainFirst :one
SELECT domain FROM service_domains WHERE service_id = $1 ORDER BY created_at ASC LIMIT 1
`

func (q *Queries) GetServiceDomainFirst(ctx context.Context, serviceID uuid.UUID) (string, error) {
	row := q.db.QueryRowContext(ctx, getServiceDomainFirst, serviceID)
	var domain string
	err := row.Scan(&domain)
	return domain, err
}

const getServicePlacementBrief = `-- name: GetServicePlacementBrief :one
SELECT name, node_id, COALESCE(spread, false) AS spread FROM services WHERE id = $1
`

type GetServicePlacementBriefRow struct {
	Name   string         `json:"name"`
	NodeID sql.NullString `json:"node_id"`
	Spread bool           `json:"spread"`
}

func (q *Queries) GetServicePlacementBrief(ctx context.Context, id uuid.UUID) (GetServicePlacementBriefRow, error) {
	row := q.db.QueryRowContext(ctx, getServicePlacementBrief, id)
	var i GetServicePlacementBriefRow
	err := row.Scan(&i.Name, &i.NodeID, &i.Spread)
	return i, err
}

const listServiceDomains = `-- name: ListServiceDomains :many
SELECT id, service_id, domain, is_default, cert_type, cert_status, last_checked_at, created_at
FROM service_domains
WHERE service_id = $1
ORDER BY is_default DESC, created_at ASC
`

func (q *Queries) ListServiceDomains(ctx context.Context, serviceID uuid.UUID) ([]ServiceDomain, error) {
	rows, err := q.db.QueryContext(ctx, listServiceDomains, serviceID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	items := []ServiceDomain{}
	for rows.Next() {
		var i ServiceDomain
		if err := rows.Scan(
			&i.ID,
			&i.ServiceID,
			&i.Domain,
			&i.IsDefault,
			&i.CertType,
			&i.CertStatus,
			&i.LastCheckedAt,
			&i.CreatedAt,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Close(); err != nil {
		return nil, err
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const serviceWriteAccess = `-- name: ServiceWriteAccess :one
SELECT EXISTS(
    SELECT 1 FROM services s JOIN projects p ON s.project_id = p.id
    WHERE s.id = $1 AND (p.owner_id = $2 OR $3::bool)
) AS allowed
`

type ServiceWriteAccessParams struct {
	ID      uuid.UUID `json:"id"`
	OwnerID uuid.UUID `json:"owner_id"`
	Column3 bool      `json:"column_3"`
}

func (q *Queries) ServiceWriteAccess(ctx context.Context, arg ServiceWriteAccessParams) (bool, error) {
	row := q.db.QueryRowContext(ctx, serviceWriteAccess, arg.ID, arg.OwnerID, arg.Column3)
	var allowed bool
	err := row.Scan(&allowed)
	return allowed, err
}

const setServiceDomainDefault = `-- name: SetServiceDomainDefault :execrows
UPDATE service_domains SET is_default = (id = $1) WHERE service_id = $2
`

type SetServiceDomainDefaultParams struct {
	ID        uuid.UUID `json:"id"`
	ServiceID uuid.UUID `json:"service_id"`
}

func (q *Queries) SetServiceDomainDefault(ctx context.Context, arg SetServiceDomainDefaultParams) (int64, error) {
	result, err := q.db.ExecContext(ctx, setServiceDomainDefault, arg.ID, arg.ServiceID)
	if err != nil {
		return 0, err
	}
	return result.RowsAffected()
}

const setServiceLegacyDomain = `-- name: SetServiceLegacyDomain :exec
UPDATE services SET domain = $1 WHERE id = $2
`

type SetServiceLegacyDomainParams struct {
	Domain string    `json:"domain"`
	ID     uuid.UUID `json:"id"`
}

func (q *Queries) SetServiceLegacyDomain(ctx context.Context, arg SetServiceLegacyDomainParams) error {
	_, err := q.db.ExecContext(ctx, setServiceLegacyDomain, arg.Domain, arg.ID)
	return err
}

const touchServiceDomainChecked = `-- name: TouchServiceDomainChecked :exec
UPDATE service_domains SET last_checked_at = NOW() WHERE id = $1
`

func (q *Queries) TouchServiceDomainChecked(ctx context.Context, id uuid.UUID) error {
	_, err := q.db.ExecContext(ctx, touchServiceDomainChecked, id)
	return err
}