multica/server/pkg/db/generated/plugin.sql.go

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

package db

import (
	"context"

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

const countRecentPluginFailures = `-- name: CountRecentPluginFailures :one
SELECT count(*) FROM plugin_invocation
WHERE installation_id = $1 AND hook_key = $2 AND created_at > $3 AND status <> 'ok'
`

type CountRecentPluginFailuresParams struct {
	InstallationID pgtype.UUID        `json:"installation_id"`
	HookKey        string             `json:"hook_key"`
	CreatedAt      pgtype.Timestamptz `json:"created_at"`
}

// Consecutive-failure signal for the event circuit breaker. Bounded by time so
// a breaker that tripped hours ago does not keep a hook shut forever.
func (q *Queries) CountRecentPluginFailures(ctx context.Context, arg CountRecentPluginFailuresParams) (int64, error) {
	row := q.db.QueryRow(ctx, countRecentPluginFailures, arg.InstallationID, arg.HookKey, arg.CreatedAt)
	var count int64
	err := row.Scan(&count)
	return count, err
}

const countRecentPluginInvocations = `-- name: CountRecentPluginInvocations :one
SELECT count(*) FROM plugin_invocation
WHERE installation_id = $1 AND hook_key = $2 AND created_at > $3
`

type CountRecentPluginInvocationsParams struct {
	InstallationID pgtype.UUID        `json:"installation_id"`
	HookKey        string             `json:"hook_key"`
	CreatedAt      pgtype.Timestamptz `json:"created_at"`
}

// Feeds the per-hook rate limit. Counts attempts, not distinct calls: a hook
// retrying into a dead endpoint is exactly the traffic the limit exists to cap.
func (q *Queries) CountRecentPluginInvocations(ctx context.Context, arg CountRecentPluginInvocationsParams) (int64, error) {
	row := q.db.QueryRow(ctx, countRecentPluginInvocations, arg.InstallationID, arg.HookKey, arg.CreatedAt)
	var count int64
	err := row.Scan(&count)
	return count, err
}

const createPluginInstallation = `-- name: CreatePluginInstallation :one
INSERT INTO plugin_installation (
    workspace_id, plugin_key, source_url, version, manifest, granted_scopes, installed_by
) VALUES ($1, $2, $3, $4, $5, $6, $7)
RETURNING id, workspace_id, plugin_key, source_url, version, manifest, granted_scopes, config, enabled, installed_by, created_at, updated_at, token_hash, token_rotated_at, mcp_approvals
`

type CreatePluginInstallationParams struct {
	WorkspaceID   pgtype.UUID `json:"workspace_id"`
	PluginKey     string      `json:"plugin_key"`
	SourceUrl     string      `json:"source_url"`
	Version       string      `json:"version"`
	Manifest      []byte      `json:"manifest"`
	GrantedScopes []byte      `json:"granted_scopes"`
	InstalledBy   pgtype.UUID `json:"installed_by"`
}

func (q *Queries) CreatePluginInstallation(ctx context.Context, arg CreatePluginInstallationParams) (PluginInstallation, error) {
	row := q.db.QueryRow(ctx, createPluginInstallation,
		arg.WorkspaceID,
		arg.PluginKey,
		arg.SourceUrl,
		arg.Version,
		arg.Manifest,
		arg.GrantedScopes,
		arg.InstalledBy,
	)
	var i PluginInstallation
	err := row.Scan(
		&i.ID,
		&i.WorkspaceID,
		&i.PluginKey,
		&i.SourceUrl,
		&i.Version,
		&i.Manifest,
		&i.GrantedScopes,
		&i.Config,
		&i.Enabled,
		&i.InstalledBy,
		&i.CreatedAt,
		&i.UpdatedAt,
		&i.TokenHash,
		&i.TokenRotatedAt,
		&i.McpApprovals,
	)
	return i, err
}

const createPluginInvocation = `-- name: CreatePluginInvocation :one
INSERT INTO plugin_invocation (
    installation_id, workspace_id, hook_key, trigger, status, event_type, attempt, latency_ms, error
) VALUES ($1, $2, $3, $4, $5, $8, $6, $7, $9)
RETURNING id, installation_id, workspace_id, hook_key, trigger, status, event_type, attempt, latency_ms, error, created_at
`

type CreatePluginInvocationParams struct {
	InstallationID pgtype.UUID `json:"installation_id"`
	WorkspaceID    pgtype.UUID `json:"workspace_id"`
	HookKey        string      `json:"hook_key"`
	Trigger        string      `json:"trigger"`
	Status         string      `json:"status"`
	Attempt        int32       `json:"attempt"`
	LatencyMs      int32       `json:"latency_ms"`
	EventType      pgtype.Text `json:"event_type"`
	Error          pgtype.Text `json:"error"`
}

func (q *Queries) CreatePluginInvocation(ctx context.Context, arg CreatePluginInvocationParams) (PluginInvocation, error) {
	row := q.db.QueryRow(ctx, createPluginInvocation,
		arg.InstallationID,
		arg.WorkspaceID,
		arg.HookKey,
		arg.Trigger,
		arg.Status,
		arg.Attempt,
		arg.LatencyMs,
		arg.EventType,
		arg.Error,
	)
	var i PluginInvocation
	err := row.Scan(
		&i.ID,
		&i.InstallationID,
		&i.WorkspaceID,
		&i.HookKey,
		&i.Trigger,
		&i.Status,
		&i.EventType,
		&i.Attempt,
		&i.LatencyMs,
		&i.Error,
		&i.CreatedAt,
	)
	return i, err
}

const deleteExpiredPluginInvocations = `-- name: DeleteExpiredPluginInvocations :execrows
DELETE FROM plugin_invocation WHERE created_at < $1
`

// TTL sweep. This table is operational telemetry, not history to keep.
func (q *Queries) DeleteExpiredPluginInvocations(ctx context.Context, createdAt pgtype.Timestamptz) (int64, error) {
	result, err := q.db.Exec(ctx, deleteExpiredPluginInvocations, createdAt)
	if err != nil {
		return 0, err
	}
	return result.RowsAffected(), nil
}

const deletePluginInstallation = `-- name: DeletePluginInstallation :exec
DELETE FROM plugin_installation WHERE id = $1
`

func (q *Queries) DeletePluginInstallation(ctx context.Context, id pgtype.UUID) error {
	_, err := q.db.Exec(ctx, deletePluginInstallation, id)
	return err
}

const deletePluginInvocationsByInstallation = `-- name: DeletePluginInvocationsByInstallation :exec
DELETE FROM plugin_invocation WHERE installation_id = $1
`

func (q *Queries) DeletePluginInvocationsByInstallation(ctx context.Context, installationID pgtype.UUID) error {
	_, err := q.db.Exec(ctx, deletePluginInvocationsByInstallation, installationID)
	return err
}

const deletePluginSecret = `-- name: DeletePluginSecret :execrows
DELETE FROM plugin_secret WHERE installation_id = $1 AND key = $2
`

type DeletePluginSecretParams struct {
	InstallationID pgtype.UUID `json:"installation_id"`
	Key            string      `json:"key"`
}

func (q *Queries) DeletePluginSecret(ctx context.Context, arg DeletePluginSecretParams) (int64, error) {
	result, err := q.db.Exec(ctx, deletePluginSecret, arg.InstallationID, arg.Key)
	if err != nil {
		return 0, err
	}
	return result.RowsAffected(), nil
}

const deletePluginSecretsByInstallation = `-- name: DeletePluginSecretsByInstallation :exec
DELETE FROM plugin_secret WHERE installation_id = $1
`

func (q *Queries) DeletePluginSecretsByInstallation(ctx context.Context, installationID pgtype.UUID) error {
	_, err := q.db.Exec(ctx, deletePluginSecretsByInstallation, installationID)
	return err
}

const deletePluginSkillsByInstallation = `-- name: DeletePluginSkillsByInstallation :exec
DELETE FROM skill WHERE plugin_installation_id = $1
`

func (q *Queries) DeletePluginSkillsByInstallation(ctx context.Context, pluginInstallationID pgtype.UUID) error {
	_, err := q.db.Exec(ctx, deletePluginSkillsByInstallation, pluginInstallationID)
	return err
}

const deletePluginSkillsNotIn = `-- name: DeletePluginSkillsNotIn :exec
DELETE FROM skill
WHERE plugin_installation_id = $1 AND name <> ALL($2::text[])
`

type DeletePluginSkillsNotInParams struct {
	PluginInstallationID pgtype.UUID `json:"plugin_installation_id"`
	KeepNames            []string    `json:"keep_names"`
}

// Upgrade pruning: a skill this installation used to contribute but no longer
// declares must go, or a renamed skill leaves its predecessor behind forever.
func (q *Queries) DeletePluginSkillsNotIn(ctx context.Context, arg DeletePluginSkillsNotInParams) error {
	_, err := q.db.Exec(ctx, deletePluginSkillsNotIn, arg.PluginInstallationID, arg.KeepNames)
	return err
}

const deletePluginStorageByInstallation = `-- name: DeletePluginStorageByInstallation :exec
DELETE FROM plugin_storage WHERE installation_id = $1
`

func (q *Queries) DeletePluginStorageByInstallation(ctx context.Context, installationID pgtype.UUID) error {
	_, err := q.db.Exec(ctx, deletePluginStorageByInstallation, installationID)
	return err
}

const deletePluginStorageValue = `-- name: DeletePluginStorageValue :execrows
DELETE FROM plugin_storage
WHERE installation_id = $1 AND scope_type = $2 AND scope_id = $3 AND key = $4
`

type DeletePluginStorageValueParams struct {
	InstallationID pgtype.UUID `json:"installation_id"`
	ScopeType      string      `json:"scope_type"`
	ScopeID        pgtype.UUID `json:"scope_id"`
	Key            string      `json:"key"`
}

func (q *Queries) DeletePluginStorageValue(ctx context.Context, arg DeletePluginStorageValueParams) (int64, error) {
	result, err := q.db.Exec(ctx, deletePluginStorageValue,
		arg.InstallationID,
		arg.ScopeType,
		arg.ScopeID,
		arg.Key,
	)
	if err != nil {
		return 0, err
	}
	return result.RowsAffected(), nil
}

const getPluginInstallation = `-- name: GetPluginInstallation :one
SELECT id, workspace_id, plugin_key, source_url, version, manifest, granted_scopes, config, enabled, installed_by, created_at, updated_at, token_hash, token_rotated_at, mcp_approvals FROM plugin_installation WHERE id = $1
`

func (q *Queries) GetPluginInstallation(ctx context.Context, id pgtype.UUID) (PluginInstallation, error) {
	row := q.db.QueryRow(ctx, getPluginInstallation, id)
	var i PluginInstallation
	err := row.Scan(
		&i.ID,
		&i.WorkspaceID,
		&i.PluginKey,
		&i.SourceUrl,
		&i.Version,
		&i.Manifest,
		&i.GrantedScopes,
		&i.Config,
		&i.Enabled,
		&i.InstalledBy,
		&i.CreatedAt,
		&i.UpdatedAt,
		&i.TokenHash,
		&i.TokenRotatedAt,
		&i.McpApprovals,
	)
	return i, err
}

const getPluginInstallationByTokenHash = `-- name: GetPluginInstallationByTokenHash :one
SELECT id, workspace_id, plugin_key, source_url, version, manifest, granted_scopes, config, enabled, installed_by, created_at, updated_at, token_hash, token_rotated_at, mcp_approvals FROM plugin_installation WHERE token_hash = $1
`

// Looked up by hash, so the plaintext token exists only in the caller's request.
func (q *Queries) GetPluginInstallationByTokenHash(ctx context.Context, tokenHash pgtype.Text) (PluginInstallation, error) {
	row := q.db.QueryRow(ctx, getPluginInstallationByTokenHash, tokenHash)
	var i PluginInstallation
	err := row.Scan(
		&i.ID,
		&i.WorkspaceID,
		&i.PluginKey,
		&i.SourceUrl,
		&i.Version,
		&i.Manifest,
		&i.GrantedScopes,
		&i.Config,
		&i.Enabled,
		&i.InstalledBy,
		&i.CreatedAt,
		&i.UpdatedAt,
		&i.TokenHash,
		&i.TokenRotatedAt,
		&i.McpApprovals,
	)
	return i, err
}

const getPluginSecret = `-- name: GetPluginSecret :one
SELECT id, installation_id, key, ciphertext, created_at, updated_at FROM plugin_secret
WHERE installation_id = $1 AND key = $2
`

type GetPluginSecretParams struct {
	InstallationID pgtype.UUID `json:"installation_id"`
	Key            string      `json:"key"`
}

func (q *Queries) GetPluginSecret(ctx context.Context, arg GetPluginSecretParams) (PluginSecret, error) {
	row := q.db.QueryRow(ctx, getPluginSecret, arg.InstallationID, arg.Key)
	var i PluginSecret
	err := row.Scan(
		&i.ID,
		&i.InstallationID,
		&i.Key,
		&i.Ciphertext,
		&i.CreatedAt,
		&i.UpdatedAt,
	)
	return i, err
}

const getPluginStorageUsage = `-- name: GetPluginStorageUsage :one
SELECT COUNT(*)::bigint AS key_count,
       COALESCE(SUM(octet_length(value)), 0)::bigint AS total_bytes
FROM plugin_storage
WHERE installation_id = $1 AND scope_type = $2 AND scope_id = $3 AND key <> $4
`

type GetPluginStorageUsageParams struct {
	InstallationID pgtype.UUID `json:"installation_id"`
	ScopeType      string      `json:"scope_type"`
	ScopeID        pgtype.UUID `json:"scope_id"`
	Key            string      `json:"key"`
}

type GetPluginStorageUsageRow struct {
	KeyCount   int64 `json:"key_count"`
	TotalBytes int64 `json:"total_bytes"`
}

// Quota accounting for one (installation, scope) pair. The candidate key is
// excluded so overwriting an existing key is measured as a replacement rather
// than an addition. octet_length, not char_length: the service compares these
// against byte budgets, and a UTF-8 character is up to 4 bytes.
func (q *Queries) GetPluginStorageUsage(ctx context.Context, arg GetPluginStorageUsageParams) (GetPluginStorageUsageRow, error) {
	row := q.db.QueryRow(ctx, getPluginStorageUsage,
		arg.InstallationID,
		arg.ScopeType,
		arg.ScopeID,
		arg.Key,
	)
	var i GetPluginStorageUsageRow
	err := row.Scan(&i.KeyCount, &i.TotalBytes)
	return i, err
}

const getPluginStorageValue = `-- name: GetPluginStorageValue :one
SELECT id, installation_id, scope_type, scope_id, key, value, created_at, updated_at FROM plugin_storage
WHERE installation_id = $1 AND scope_type = $2 AND scope_id = $3 AND key = $4
`

type GetPluginStorageValueParams struct {
	InstallationID pgtype.UUID `json:"installation_id"`
	ScopeType      string      `json:"scope_type"`
	ScopeID        pgtype.UUID `json:"scope_id"`
	Key            string      `json:"key"`
}

func (q *Queries) GetPluginStorageValue(ctx context.Context, arg GetPluginStorageValueParams) (PluginStorage, error) {
	row := q.db.QueryRow(ctx, getPluginStorageValue,
		arg.InstallationID,
		arg.ScopeType,
		arg.ScopeID,
		arg.Key,
	)
	var i PluginStorage
	err := row.Scan(
		&i.ID,
		&i.InstallationID,
		&i.ScopeType,
		&i.ScopeID,
		&i.Key,
		&i.Value,
		&i.CreatedAt,
		&i.UpdatedAt,
	)
	return i, err
}

const getWorkspacePluginInstallation = `-- name: GetWorkspacePluginInstallation :one
SELECT id, workspace_id, plugin_key, source_url, version, manifest, granted_scopes, config, enabled, installed_by, created_at, updated_at, token_hash, token_rotated_at, mcp_approvals FROM plugin_installation
WHERE workspace_id = $1 AND id = $2
`

type GetWorkspacePluginInstallationParams struct {
	WorkspaceID pgtype.UUID `json:"workspace_id"`
	ID          pgtype.UUID `json:"id"`
}

func (q *Queries) GetWorkspacePluginInstallation(ctx context.Context, arg GetWorkspacePluginInstallationParams) (PluginInstallation, error) {
	row := q.db.QueryRow(ctx, getWorkspacePluginInstallation, arg.WorkspaceID, arg.ID)
	var i PluginInstallation
	err := row.Scan(
		&i.ID,
		&i.WorkspaceID,
		&i.PluginKey,
		&i.SourceUrl,
		&i.Version,
		&i.Manifest,
		&i.GrantedScopes,
		&i.Config,
		&i.Enabled,
		&i.InstalledBy,
		&i.CreatedAt,
		&i.UpdatedAt,
		&i.TokenHash,
		&i.TokenRotatedAt,
		&i.McpApprovals,
	)
	return i, err
}

const getWorkspacePluginInstallationByKey = `-- name: GetWorkspacePluginInstallationByKey :one
SELECT id, workspace_id, plugin_key, source_url, version, manifest, granted_scopes, config, enabled, installed_by, created_at, updated_at, token_hash, token_rotated_at, mcp_approvals FROM plugin_installation
WHERE workspace_id = $1 AND plugin_key = $2
`

type GetWorkspacePluginInstallationByKeyParams struct {
	WorkspaceID pgtype.UUID `json:"workspace_id"`
	PluginKey   string      `json:"plugin_key"`
}

func (q *Queries) GetWorkspacePluginInstallationByKey(ctx context.Context, arg GetWorkspacePluginInstallationByKeyParams) (PluginInstallation, error) {
	row := q.db.QueryRow(ctx, getWorkspacePluginInstallationByKey, arg.WorkspaceID, arg.PluginKey)
	var i PluginInstallation
	err := row.Scan(
		&i.ID,
		&i.WorkspaceID,
		&i.PluginKey,
		&i.SourceUrl,
		&i.Version,
		&i.Manifest,
		&i.GrantedScopes,
		&i.Config,
		&i.Enabled,
		&i.InstalledBy,
		&i.CreatedAt,
		&i.UpdatedAt,
		&i.TokenHash,
		&i.TokenRotatedAt,
		&i.McpApprovals,
	)
	return i, err
}

const listPluginInvocations = `-- name: ListPluginInvocations :many
SELECT id, installation_id, workspace_id, hook_key, trigger, status, event_type, attempt, latency_ms, error, created_at FROM plugin_invocation
WHERE installation_id = $1
ORDER BY created_at DESC
LIMIT $2
`

type ListPluginInvocationsParams struct {
	InstallationID pgtype.UUID `json:"installation_id"`
	Limit          int32       `json:"limit"`
}

func (q *Queries) ListPluginInvocations(ctx context.Context, arg ListPluginInvocationsParams) ([]PluginInvocation, error) {
	rows, err := q.db.Query(ctx, listPluginInvocations, arg.InstallationID, arg.Limit)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	items := []PluginInvocation{}
	for rows.Next() {
		var i PluginInvocation
		if err := rows.Scan(
			&i.ID,
			&i.InstallationID,
			&i.WorkspaceID,
			&i.HookKey,
			&i.Trigger,
			&i.Status,
			&i.EventType,
			&i.Attempt,
			&i.LatencyMs,
			&i.Error,
			&i.CreatedAt,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const listPluginSecretKeys = `-- name: ListPluginSecretKeys :many
SELECT key, updated_at FROM plugin_secret
WHERE installation_id = $1
ORDER BY key ASC
`

type ListPluginSecretKeysRow struct {
	Key       string             `json:"key"`
	UpdatedAt pgtype.Timestamptz `json:"updated_at"`
}

// Deliberately never selects ciphertext: the presence of a secret is readable,
// its value is not.
func (q *Queries) ListPluginSecretKeys(ctx context.Context, installationID pgtype.UUID) ([]ListPluginSecretKeysRow, error) {
	rows, err := q.db.Query(ctx, listPluginSecretKeys, installationID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	items := []ListPluginSecretKeysRow{}
	for rows.Next() {
		var i ListPluginSecretKeysRow
		if err := rows.Scan(&i.Key, &i.UpdatedAt); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const listPluginSkills = `-- name: ListPluginSkills :many
SELECT id, workspace_id, name, description, content, config, created_by, created_at, updated_at, plugin_installation_id FROM skill WHERE plugin_installation_id = $1 ORDER BY name ASC
`

func (q *Queries) ListPluginSkills(ctx context.Context, pluginInstallationID pgtype.UUID) ([]Skill, error) {
	rows, err := q.db.Query(ctx, listPluginSkills, pluginInstallationID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	items := []Skill{}
	for rows.Next() {
		var i Skill
		if err := rows.Scan(
			&i.ID,
			&i.WorkspaceID,
			&i.Name,
			&i.Description,
			&i.Content,
			&i.Config,
			&i.CreatedBy,
			&i.CreatedAt,
			&i.UpdatedAt,
			&i.PluginInstallationID,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const listPluginStorageKeys = `-- name: ListPluginStorageKeys :many
SELECT key, octet_length(value)::bigint AS size_bytes, updated_at
FROM plugin_storage
WHERE installation_id = $1 AND scope_type = $2 AND scope_id = $3
ORDER BY key ASC
`

type ListPluginStorageKeysParams struct {
	InstallationID pgtype.UUID `json:"installation_id"`
	ScopeType      string      `json:"scope_type"`
	ScopeID        pgtype.UUID `json:"scope_id"`
}

type ListPluginStorageKeysRow struct {
	Key       string             `json:"key"`
	SizeBytes int64              `json:"size_bytes"`
	UpdatedAt pgtype.Timestamptz `json:"updated_at"`
}

func (q *Queries) ListPluginStorageKeys(ctx context.Context, arg ListPluginStorageKeysParams) ([]ListPluginStorageKeysRow, error) {
	rows, err := q.db.Query(ctx, listPluginStorageKeys, arg.InstallationID, arg.ScopeType, arg.ScopeID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	items := []ListPluginStorageKeysRow{}
	for rows.Next() {
		var i ListPluginStorageKeysRow
		if err := rows.Scan(&i.Key, &i.SizeBytes, &i.UpdatedAt); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const listWorkspacePluginInstallations = `-- name: ListWorkspacePluginInstallations :many
SELECT id, workspace_id, plugin_key, source_url, version, manifest, granted_scopes, config, enabled, installed_by, created_at, updated_at, token_hash, token_rotated_at, mcp_approvals FROM plugin_installation
WHERE workspace_id = $1
ORDER BY created_at ASC
`

func (q *Queries) ListWorkspacePluginInstallations(ctx context.Context, workspaceID pgtype.UUID) ([]PluginInstallation, error) {
	rows, err := q.db.Query(ctx, listWorkspacePluginInstallations, workspaceID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	items := []PluginInstallation{}
	for rows.Next() {
		var i PluginInstallation
		if err := rows.Scan(
			&i.ID,
			&i.WorkspaceID,
			&i.PluginKey,
			&i.SourceUrl,
			&i.Version,
			&i.Manifest,
			&i.GrantedScopes,
			&i.Config,
			&i.Enabled,
			&i.InstalledBy,
			&i.CreatedAt,
			&i.UpdatedAt,
			&i.TokenHash,
			&i.TokenRotatedAt,
			&i.McpApprovals,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const setPluginInstallationEnabled = `-- name: SetPluginInstallationEnabled :one
UPDATE plugin_installation
SET enabled = $2,
    updated_at = now()
WHERE id = $1
RETURNING id, workspace_id, plugin_key, source_url, version, manifest, granted_scopes, config, enabled, installed_by, created_at, updated_at, token_hash, token_rotated_at, mcp_approvals
`

type SetPluginInstallationEnabledParams struct {
	ID      pgtype.UUID `json:"id"`
	Enabled bool        `json:"enabled"`
}

func (q *Queries) SetPluginInstallationEnabled(ctx context.Context, arg SetPluginInstallationEnabledParams) (PluginInstallation, error) {
	row := q.db.QueryRow(ctx, setPluginInstallationEnabled, arg.ID, arg.Enabled)
	var i PluginInstallation
	err := row.Scan(
		&i.ID,
		&i.WorkspaceID,
		&i.PluginKey,
		&i.SourceUrl,
		&i.Version,
		&i.Manifest,
		&i.GrantedScopes,
		&i.Config,
		&i.Enabled,
		&i.InstalledBy,
		&i.CreatedAt,
		&i.UpdatedAt,
		&i.TokenHash,
		&i.TokenRotatedAt,
		&i.McpApprovals,
	)
	return i, err
}

const setPluginInstallationToken = `-- name: SetPluginInstallationToken :exec
UPDATE plugin_installation
SET token_hash = $2, token_rotated_at = now(), updated_at = now()
WHERE id = $1
`

type SetPluginInstallationTokenParams struct {
	ID        pgtype.UUID `json:"id"`
	TokenHash pgtype.Text `json:"token_hash"`
}

func (q *Queries) SetPluginInstallationToken(ctx context.Context, arg SetPluginInstallationTokenParams) error {
	_, err := q.db.Exec(ctx, setPluginInstallationToken, arg.ID, arg.TokenHash)
	return err
}

const setPluginMCPApprovals = `-- name: SetPluginMCPApprovals :one
UPDATE plugin_installation
SET mcp_approvals = $2, updated_at = now()
WHERE id = $1
RETURNING id, workspace_id, plugin_key, source_url, version, manifest, granted_scopes, config, enabled, installed_by, created_at, updated_at, token_hash, token_rotated_at, mcp_approvals
`

type SetPluginMCPApprovalsParams struct {
	ID           pgtype.UUID `json:"id"`
	McpApprovals []byte      `json:"mcp_approvals"`
}

func (q *Queries) SetPluginMCPApprovals(ctx context.Context, arg SetPluginMCPApprovalsParams) (PluginInstallation, error) {
	row := q.db.QueryRow(ctx, setPluginMCPApprovals, arg.ID, arg.McpApprovals)
	var i PluginInstallation
	err := row.Scan(
		&i.ID,
		&i.WorkspaceID,
		&i.PluginKey,
		&i.SourceUrl,
		&i.Version,
		&i.Manifest,
		&i.GrantedScopes,
		&i.Config,
		&i.Enabled,
		&i.InstalledBy,
		&i.CreatedAt,
		&i.UpdatedAt,
		&i.TokenHash,
		&i.TokenRotatedAt,
		&i.McpApprovals,
	)
	return i, err
}

const updatePluginInstallationConfig = `-- name: UpdatePluginInstallationConfig :one
UPDATE plugin_installation
SET config = $2,
    updated_at = now()
WHERE id = $1
RETURNING id, workspace_id, plugin_key, source_url, version, manifest, granted_scopes, config, enabled, installed_by, created_at, updated_at, token_hash, token_rotated_at, mcp_approvals
`

type UpdatePluginInstallationConfigParams struct {
	ID     pgtype.UUID `json:"id"`
	Config []byte      `json:"config"`
}

func (q *Queries) UpdatePluginInstallationConfig(ctx context.Context, arg UpdatePluginInstallationConfigParams) (PluginInstallation, error) {
	row := q.db.QueryRow(ctx, updatePluginInstallationConfig, arg.ID, arg.Config)
	var i PluginInstallation
	err := row.Scan(
		&i.ID,
		&i.WorkspaceID,
		&i.PluginKey,
		&i.SourceUrl,
		&i.Version,
		&i.Manifest,
		&i.GrantedScopes,
		&i.Config,
		&i.Enabled,
		&i.InstalledBy,
		&i.CreatedAt,
		&i.UpdatedAt,
		&i.TokenHash,
		&i.TokenRotatedAt,
		&i.McpApprovals,
	)
	return i, err
}

const updatePluginInstallationManifest = `-- name: UpdatePluginInstallationManifest :one
UPDATE plugin_installation
SET source_url = $2,
    version = $3,
    manifest = $4,
    granted_scopes = $5,
    config = $6,
    updated_at = now()
WHERE id = $1
RETURNING id, workspace_id, plugin_key, source_url, version, manifest, granted_scopes, config, enabled, installed_by, created_at, updated_at, token_hash, token_rotated_at, mcp_approvals
`

type UpdatePluginInstallationManifestParams struct {
	ID            pgtype.UUID `json:"id"`
	SourceUrl     string      `json:"source_url"`
	Version       string      `json:"version"`
	Manifest      []byte      `json:"manifest"`
	GrantedScopes []byte      `json:"granted_scopes"`
	Config        []byte      `json:"config"`
}

// Upgrade path: the re-consented manifest snapshot replaces the old one in
// place. Config values survive on purpose; fields the new manifest dropped are
// pruned by the service before this runs.
func (q *Queries) UpdatePluginInstallationManifest(ctx context.Context, arg UpdatePluginInstallationManifestParams) (PluginInstallation, error) {
	row := q.db.QueryRow(ctx, updatePluginInstallationManifest,
		arg.ID,
		arg.SourceUrl,
		arg.Version,
		arg.Manifest,
		arg.GrantedScopes,
		arg.Config,
	)
	var i PluginInstallation
	err := row.Scan(
		&i.ID,
		&i.WorkspaceID,
		&i.PluginKey,
		&i.SourceUrl,
		&i.Version,
		&i.Manifest,
		&i.GrantedScopes,
		&i.Config,
		&i.Enabled,
		&i.InstalledBy,
		&i.CreatedAt,
		&i.UpdatedAt,
		&i.TokenHash,
		&i.TokenRotatedAt,
		&i.McpApprovals,
	)
	return i, err
}

const upsertPluginSecret = `-- name: UpsertPluginSecret :exec
INSERT INTO plugin_secret (installation_id, key, ciphertext)
VALUES ($1, $2, $3)
ON CONFLICT (installation_id, key)
DO UPDATE SET ciphertext = EXCLUDED.ciphertext, updated_at = now()
`

type UpsertPluginSecretParams struct {
	InstallationID pgtype.UUID `json:"installation_id"`
	Key            string      `json:"key"`
	Ciphertext     []byte      `json:"ciphertext"`
}

func (q *Queries) UpsertPluginSecret(ctx context.Context, arg UpsertPluginSecretParams) error {
	_, err := q.db.Exec(ctx, upsertPluginSecret, arg.InstallationID, arg.Key, arg.Ciphertext)
	return err
}

const upsertPluginSkill = `-- name: UpsertPluginSkill :one
INSERT INTO skill (workspace_id, name, description, content, config, created_by, plugin_installation_id)
VALUES ($1, $2, $3, $4, '{}'::jsonb, $6, $5)
ON CONFLICT (workspace_id, name) DO UPDATE SET
    description = EXCLUDED.description,
    content = EXCLUDED.content,
    updated_at = now()
WHERE skill.plugin_installation_id = EXCLUDED.plugin_installation_id
RETURNING id, workspace_id, name, description, content, config, created_by, created_at, updated_at, plugin_installation_id
`

type UpsertPluginSkillParams struct {
	WorkspaceID          pgtype.UUID `json:"workspace_id"`
	Name                 string      `json:"name"`
	Description          string      `json:"description"`
	Content              string      `json:"content"`
	PluginInstallationID pgtype.UUID `json:"plugin_installation_id"`
	CreatedBy            pgtype.UUID `json:"created_by"`
}

// A plugin's skill resource, as an ordinary workspace skill.
//
// Upsert on (workspace_id, name) because that is the table's own uniqueness
// rule and an upgrade re-installs the same skill. The WHERE clause is the
// important half: it refuses to overwrite a skill a PERSON created, or one
// another installation owns. A plugin claiming a name someone already used must
// fail the install loudly, not silently replace their work.
func (q *Queries) UpsertPluginSkill(ctx context.Context, arg UpsertPluginSkillParams) (Skill, error) {
	row := q.db.QueryRow(ctx, upsertPluginSkill,
		arg.WorkspaceID,
		arg.Name,
		arg.Description,
		arg.Content,
		arg.PluginInstallationID,
		arg.CreatedBy,
	)
	var i Skill
	err := row.Scan(
		&i.ID,
		&i.WorkspaceID,
		&i.Name,
		&i.Description,
		&i.Content,
		&i.Config,
		&i.CreatedBy,
		&i.CreatedAt,
		&i.UpdatedAt,
		&i.PluginInstallationID,
	)
	return i, err
}

const upsertPluginStorageValue = `-- name: UpsertPluginStorageValue :one
INSERT INTO plugin_storage (installation_id, scope_type, scope_id, key, value)
VALUES ($1, $2, $3, $4, $5)
ON CONFLICT (installation_id, scope_type, scope_id, key)
DO UPDATE SET value = EXCLUDED.value, updated_at = now()
RETURNING id, installation_id, scope_type, scope_id, key, value, created_at, updated_at
`

type UpsertPluginStorageValueParams struct {
	InstallationID pgtype.UUID `json:"installation_id"`
	ScopeType      string      `json:"scope_type"`
	ScopeID        pgtype.UUID `json:"scope_id"`
	Key            string      `json:"key"`
	Value          string      `json:"value"`
}

func (q *Queries) UpsertPluginStorageValue(ctx context.Context, arg UpsertPluginStorageValueParams) (PluginStorage, error) {
	row := q.db.QueryRow(ctx, upsertPluginStorageValue,
		arg.InstallationID,
		arg.ScopeType,
		arg.ScopeID,
		arg.Key,
		arg.Value,
	)
	var i PluginStorage
	err := row.Scan(
		&i.ID,
		&i.InstallationID,
		&i.ScopeType,
		&i.ScopeID,
		&i.Key,
		&i.Value,
		&i.CreatedAt,
		&i.UpdatedAt,
	)
	return i, err
}