member-console/internal/domains/placements.sql.go

// Code generated by sqlc. DO NOT EDIT.
// versions:
//   sqlc v1.29.0
// source: placements.sql

package domains

import (
	"context"
	"time"

	"github.com/lib/pq"
)

const countPlacementsByClaim = `-- name: CountPlacementsByClaim :one
SELECT COUNT(*) FROM domains.placements
WHERE claim_id = $1
`

// Re-read under the registry advisory lock before auto-releasing a claim,
// so a release racing a placement cannot strand a live placement in a
// released claim (design D3).
func (q *Queries) CountPlacementsByClaim(ctx context.Context, claimID string) (int64, error) {
	row := q.db.QueryRowContext(ctx, countPlacementsByClaim, claimID)
	var count int64
	err := row.Scan(&count)
	return count, err
}

const createPlacement = `-- name: CreatePlacement :one
INSERT INTO domains.placements (claim_id, fqdn, reversed_labels, provider, resource_ref, servable)
VALUES ($1, $2, $3, $4, $5, $6)
RETURNING placement_id, claim_id, fqdn, reversed_labels, provider, resource_ref, servable, created_at, updated_at
`

type CreatePlacementParams struct {
	ClaimID        string `json:"claim_id"`
	Fqdn           string `json:"fqdn"`
	ReversedLabels string `json:"reversed_labels"`
	Provider       string `json:"provider"`
	ResourceRef    string `json:"resource_ref"`
	Servable       bool   `json:"servable"`
}

func (q *Queries) CreatePlacement(ctx context.Context, arg CreatePlacementParams) (Placement, error) {
	row := q.db.QueryRowContext(ctx, createPlacement,
		arg.ClaimID,
		arg.Fqdn,
		arg.ReversedLabels,
		arg.Provider,
		arg.ResourceRef,
		arg.Servable,
	)
	var i Placement
	err := row.Scan(
		&i.PlacementID,
		&i.ClaimID,
		&i.Fqdn,
		&i.ReversedLabels,
		&i.Provider,
		&i.ResourceRef,
		&i.Servable,
		&i.CreatedAt,
		&i.UpdatedAt,
	)
	return i, err
}

const deletePlacement = `-- name: DeletePlacement :execrows
DELETE FROM domains.placements
WHERE placement_id = $1
`

func (q *Queries) DeletePlacement(ctx context.Context, placementID string) (int64, error) {
	result, err := q.db.ExecContext(ctx, deletePlacement, placementID)
	if err != nil {
		return 0, err
	}
	return result.RowsAffected()
}

const getPlacementByFQDN = `-- name: GetPlacementByFQDN :one
SELECT placement_id, claim_id, fqdn, reversed_labels, provider, resource_ref, servable, created_at, updated_at FROM domains.placements
WHERE fqdn = $1
`

// The serving path (/domains/ask). Deliberately unconditional: a row with
// servable = false is a local refusal, distinct from a registry miss, and
// the authorizer needs to tell those apart (design D5).
func (q *Queries) GetPlacementByFQDN(ctx context.Context, fqdn string) (Placement, error) {
	row := q.db.QueryRowContext(ctx, getPlacementByFQDN, fqdn)
	var i Placement
	err := row.Scan(
		&i.PlacementID,
		&i.ClaimID,
		&i.Fqdn,
		&i.ReversedLabels,
		&i.Provider,
		&i.ResourceRef,
		&i.Servable,
		&i.CreatedAt,
		&i.UpdatedAt,
	)
	return i, err
}

const getPlacementByID = `-- name: GetPlacementByID :one
SELECT placement_id, claim_id, fqdn, reversed_labels, provider, resource_ref, servable, created_at, updated_at FROM domains.placements
WHERE placement_id = $1
`

// The release path reads the placement before deleting it: the claim_id it
// carries is what the auto-release re-count needs.
func (q *Queries) GetPlacementByID(ctx context.Context, placementID string) (Placement, error) {
	row := q.db.QueryRowContext(ctx, getPlacementByID, placementID)
	var i Placement
	err := row.Scan(
		&i.PlacementID,
		&i.ClaimID,
		&i.Fqdn,
		&i.ReversedLabels,
		&i.Provider,
		&i.ResourceRef,
		&i.Servable,
		&i.CreatedAt,
		&i.UpdatedAt,
	)
	return i, err
}

const getPlacementByResource = `-- name: GetPlacementByResource :one
SELECT placement_id, claim_id, fqdn, reversed_labels, provider, resource_ref, servable, created_at, updated_at FROM domains.placements
WHERE provider = $1 AND resource_ref = $2
`

type GetPlacementByResourceParams struct {
	Provider    string `json:"provider"`
	ResourceRef string `json:"resource_ref"`
}

func (q *Queries) GetPlacementByResource(ctx context.Context, arg GetPlacementByResourceParams) (Placement, error) {
	row := q.db.QueryRowContext(ctx, getPlacementByResource, arg.Provider, arg.ResourceRef)
	var i Placement
	err := row.Scan(
		&i.PlacementID,
		&i.ClaimID,
		&i.Fqdn,
		&i.ReversedLabels,
		&i.Provider,
		&i.ResourceRef,
		&i.Servable,
		&i.CreatedAt,
		&i.UpdatedAt,
	)
	return i, err
}

const listAllPlacementsForOperator = `-- name: ListAllPlacementsForOperator :many
SELECT placement_id, claim_id, fqdn, provider, resource_ref, servable, created_at
FROM domains.placements
ORDER BY fqdn
`

type ListAllPlacementsForOperatorRow struct {
	PlacementID string    `json:"placement_id"`
	ClaimID     string    `json:"claim_id"`
	Fqdn        string    `json:"fqdn"`
	Provider    string    `json:"provider"`
	ResourceRef string    `json:"resource_ref"`
	Servable    bool      `json:"servable"`
	CreatedAt   time.Time `json:"created_at"`
}

// The operator placements section (ux-ia-naming task 9.1): every exact name
// actually being served, deployment-wide, each with the provider resource it
// is wired to. Claims and placements are never conflated
// (docs/models/domains-registry.md, "Claim vs placement") -- a claim can hold
// a name that serves nothing, and this is the query that answers what
// actually serves. Ordered by fqdn so the list reads in the same namespace
// order as the claims table above it.
func (q *Queries) ListAllPlacementsForOperator(ctx context.Context) ([]ListAllPlacementsForOperatorRow, error) {
	rows, err := q.db.QueryContext(ctx, listAllPlacementsForOperator)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	items := []ListAllPlacementsForOperatorRow{}
	for rows.Next() {
		var i ListAllPlacementsForOperatorRow
		if err := rows.Scan(
			&i.PlacementID,
			&i.ClaimID,
			&i.Fqdn,
			&i.Provider,
			&i.ResourceRef,
			&i.Servable,
			&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 listPlacementsByClaim = `-- name: ListPlacementsByClaim :many
SELECT placement_id, claim_id, fqdn, reversed_labels, provider, resource_ref, servable, created_at, updated_at FROM domains.placements
WHERE claim_id = $1
ORDER BY fqdn
`

func (q *Queries) ListPlacementsByClaim(ctx context.Context, claimID string) ([]Placement, error) {
	rows, err := q.db.QueryContext(ctx, listPlacementsByClaim, claimID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	items := []Placement{}
	for rows.Next() {
		var i Placement
		if err := rows.Scan(
			&i.PlacementID,
			&i.ClaimID,
			&i.Fqdn,
			&i.ReversedLabels,
			&i.Provider,
			&i.ResourceRef,
			&i.Servable,
			&i.CreatedAt,
			&i.UpdatedAt,
		); 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 listPlacementsByFQDNs = `-- name: ListPlacementsByFQDNs :many
SELECT placement_id, claim_id, fqdn, reversed_labels, provider, resource_ref, servable, created_at, updated_at FROM domains.placements
WHERE fqdn = ANY($1::text[])
ORDER BY length(fqdn) DESC
`

// Ancestor walk on placements: an operator placement above a candidate root
// blocks carving it. Exact equality keeps this on the fqdn unique index.
func (q *Queries) ListPlacementsByFQDNs(ctx context.Context, fqdns []string) ([]Placement, error) {
	rows, err := q.db.QueryContext(ctx, listPlacementsByFQDNs, pq.Array(fqdns))
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	items := []Placement{}
	for rows.Next() {
		var i Placement
		if err := rows.Scan(
			&i.PlacementID,
			&i.ClaimID,
			&i.Fqdn,
			&i.ReversedLabels,
			&i.Provider,
			&i.ResourceRef,
			&i.Servable,
			&i.CreatedAt,
			&i.UpdatedAt,
		); 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 listPlacementsInSubtree = `-- name: ListPlacementsInSubtree :many
SELECT placement_id, claim_id, fqdn, reversed_labels, provider, resource_ref, servable, created_at, updated_at FROM domains.placements
WHERE reversed_labels LIKE $1::text || '.%'
ORDER BY reversed_labels
`

// Descendant scan via the reversed-label prefix; excludes the subtree root
// itself (an exact hit is the unique index's business).
func (q *Queries) ListPlacementsInSubtree(ctx context.Context, reversedRoot string) ([]Placement, error) {
	rows, err := q.db.QueryContext(ctx, listPlacementsInSubtree, reversedRoot)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	items := []Placement{}
	for rows.Next() {
		var i Placement
		if err := rows.Scan(
			&i.PlacementID,
			&i.ClaimID,
			&i.Fqdn,
			&i.ReversedLabels,
			&i.Provider,
			&i.ResourceRef,
			&i.Servable,
			&i.CreatedAt,
			&i.UpdatedAt,
		); 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 setPlacementServableByResource = `-- name: SetPlacementServableByResource :execrows
UPDATE domains.placements
SET servable = $3, updated_at = NOW()
WHERE provider = $1 AND resource_ref = $2
`

type SetPlacementServableByResourceParams struct {
	Provider    string `json:"provider"`
	ResourceRef string `json:"resource_ref"`
	Servable    bool   `json:"servable"`
}

// Provider lifecycle transitions address placements by their own resource
// identity, not by name (fedwiki: archive => FALSE, restore => TRUE).
func (q *Queries) SetPlacementServableByResource(ctx context.Context, arg SetPlacementServableByResourceParams) (int64, error) {
	result, err := q.db.ExecContext(ctx, setPlacementServableByResource, arg.Provider, arg.ResourceRef, arg.Servable)
	if err != nil {
		return 0, err
	}
	return result.RowsAffected()
}