member-console/internal/integration/providers.sql.go

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

package integration

import (
	"context"
	"database/sql"
)

const getProvider = `-- name: GetProvider :one
SELECT provider, provider_kind, display_name, operator_surface_path, status, created_at, updated_at, suspended_at, retired_at FROM core.providers WHERE provider = $1
`

func (q *Queries) GetProvider(ctx context.Context, provider string) (Provider, error) {
	row := q.db.QueryRowContext(ctx, getProvider, provider)
	var i Provider
	err := row.Scan(
		&i.Provider,
		&i.ProviderKind,
		&i.DisplayName,
		&i.OperatorSurfacePath,
		&i.Status,
		&i.CreatedAt,
		&i.UpdatedAt,
		&i.SuspendedAt,
		&i.RetiredAt,
	)
	return i, err
}

const listPlatformResourceKeys = `-- name: ListPlatformResourceKeys :many
SELECT resource_key FROM core.resource_keys WHERE provider IS NULL ORDER BY resource_key
`

// Platform-owned (unprefixed) resource keys, for the provider-key hygiene
// nesting check.
func (q *Queries) ListPlatformResourceKeys(ctx context.Context) ([]string, error) {
	rows, err := q.db.QueryContext(ctx, listPlatformResourceKeys)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	items := []string{}
	for rows.Next() {
		var resource_key string
		if err := rows.Scan(&resource_key); err != nil {
			return nil, err
		}
		items = append(items, resource_key)
	}
	if err := rows.Close(); err != nil {
		return nil, err
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const listProviders = `-- name: ListProviders :many
SELECT provider, provider_kind, display_name, operator_surface_path, status, created_at, updated_at, suspended_at, retired_at FROM core.providers ORDER BY provider
`

func (q *Queries) ListProviders(ctx context.Context) ([]Provider, error) {
	rows, err := q.db.QueryContext(ctx, listProviders)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	items := []Provider{}
	for rows.Next() {
		var i Provider
		if err := rows.Scan(
			&i.Provider,
			&i.ProviderKind,
			&i.DisplayName,
			&i.OperatorSurfacePath,
			&i.Status,
			&i.CreatedAt,
			&i.UpdatedAt,
			&i.SuspendedAt,
			&i.RetiredAt,
		); 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 listProvidersByKind = `-- name: ListProvidersByKind :many
SELECT provider, provider_kind, display_name, operator_surface_path, status, created_at, updated_at, suspended_at, retired_at FROM core.providers WHERE provider_kind = $1 ORDER BY provider
`

func (q *Queries) ListProvidersByKind(ctx context.Context, providerKind string) ([]Provider, error) {
	rows, err := q.db.QueryContext(ctx, listProvidersByKind, providerKind)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	items := []Provider{}
	for rows.Next() {
		var i Provider
		if err := rows.Scan(
			&i.Provider,
			&i.ProviderKind,
			&i.DisplayName,
			&i.OperatorSurfacePath,
			&i.Status,
			&i.CreatedAt,
			&i.UpdatedAt,
			&i.SuspendedAt,
			&i.RetiredAt,
		); 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 setProviderStatus = `-- name: SetProviderStatus :exec
UPDATE core.providers SET status = $2, updated_at = NOW() WHERE provider = $1
`

type SetProviderStatusParams struct {
	Provider string `json:"provider"`
	Status   string `json:"status"`
}

// Operational mutation (operator-editable), distinct from capability registration.
func (q *Queries) SetProviderStatus(ctx context.Context, arg SetProviderStatusParams) error {
	_, err := q.db.ExecContext(ctx, setProviderStatus, arg.Provider, arg.Status)
	return err
}

const setResourceKeyProvider = `-- name: SetResourceKeyProvider :execrows
UPDATE core.resource_keys SET provider = $2 WHERE resource_key = $1
`

type SetResourceKeyProviderParams struct {
	ResourceKey string         `json:"resource_key"`
	Provider    sql.NullString `json:"provider"`
}

// Stamp provider ownership on a resource key (cross-schema write, enabled by the
// resource_keys.provider FK + this package's core_writer grant on the core
// schema). Returns rows affected so a manifest referencing a non-existent key
// can be detected at registration.
func (q *Queries) SetResourceKeyProvider(ctx context.Context, arg SetResourceKeyProviderParams) (int64, error) {
	result, err := q.db.ExecContext(ctx, setResourceKeyProvider, arg.ResourceKey, arg.Provider)
	if err != nil {
		return 0, err
	}
	return result.RowsAffected()
}

const upsertProvider = `-- name: UpsertProvider :one
INSERT INTO core.providers (provider, provider_kind, display_name, operator_surface_path)
VALUES ($1, $2, $3, $4)
ON CONFLICT (provider) DO UPDATE
SET provider_kind         = EXCLUDED.provider_kind,
    display_name          = EXCLUDED.display_name,
    operator_surface_path = EXCLUDED.operator_surface_path,
    updated_at            = NOW()
RETURNING provider, provider_kind, display_name, operator_surface_path, status, created_at, updated_at, suspended_at, retired_at
`

type UpsertProviderParams struct {
	Provider            string         `json:"provider"`
	ProviderKind        string         `json:"provider_kind"`
	DisplayName         string         `json:"display_name"`
	OperatorSurfacePath sql.NullString `json:"operator_surface_path"`
}

// Boot-time capability registration. On re-registration, capability fields
// (kind, display_name) are refreshed; operational `status` is preserved.
func (q *Queries) UpsertProvider(ctx context.Context, arg UpsertProviderParams) (Provider, error) {
	row := q.db.QueryRowContext(ctx, upsertProvider,
		arg.Provider,
		arg.ProviderKind,
		arg.DisplayName,
		arg.OperatorSurfacePath,
	)
	var i Provider
	err := row.Scan(
		&i.Provider,
		&i.ProviderKind,
		&i.DisplayName,
		&i.OperatorSurfacePath,
		&i.Status,
		&i.CreatedAt,
		&i.UpdatedAt,
		&i.SuspendedAt,
		&i.RetiredAt,
	)
	return i, err
}