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

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

package db

import (
	"context"

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

const addAgentMcpServer = `-- name: AddAgentMcpServer :exec
INSERT INTO agent_mcp_server (agent_id, server_id)
VALUES ($1, $2)
ON CONFLICT DO NOTHING
`

type AddAgentMcpServerParams struct {
	AgentID  pgtype.UUID `json:"agent_id"`
	ServerID pgtype.UUID `json:"server_id"`
}

func (q *Queries) AddAgentMcpServer(ctx context.Context, arg AddAgentMcpServerParams) error {
	_, err := q.db.Exec(ctx, addAgentMcpServer, arg.AgentID, arg.ServerID)
	return err
}

const countWorkspaceMcpServerAgents = `-- name: CountWorkspaceMcpServerAgents :many
SELECT ams.server_id, COUNT(*)::bigint AS agent_count
FROM agent_mcp_server ams
JOIN workspace_mcp_server s ON s.id = ams.server_id
JOIN agent a ON a.id = ams.agent_id
WHERE s.workspace_id = $1 AND a.archived_at IS NULL
GROUP BY ams.server_id
`

type CountWorkspaceMcpServerAgentsRow struct {
	ServerID   pgtype.UUID `json:"server_id"`
	AgentCount int64       `json:"agent_count"`
}

// How many live agents each library entry is assigned to, for the workspace
// settings list. Archived agents never receive the server, so they are not
// counted; servers with no assignment are simply absent from the result.
func (q *Queries) CountWorkspaceMcpServerAgents(ctx context.Context, workspaceID pgtype.UUID) ([]CountWorkspaceMcpServerAgentsRow, error) {
	rows, err := q.db.Query(ctx, countWorkspaceMcpServerAgents, workspaceID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	items := []CountWorkspaceMcpServerAgentsRow{}
	for rows.Next() {
		var i CountWorkspaceMcpServerAgentsRow
		if err := rows.Scan(&i.ServerID, &i.AgentCount); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const createWorkspaceMcpServer = `-- name: CreateWorkspaceMcpServer :one
INSERT INTO workspace_mcp_server (workspace_id, name, config, created_by)
VALUES ($1, $2, $3, $4)
RETURNING id, workspace_id, name, config, created_by, created_at, updated_at
`

type CreateWorkspaceMcpServerParams struct {
	WorkspaceID pgtype.UUID `json:"workspace_id"`
	Name        string      `json:"name"`
	Config      []byte      `json:"config"`
	CreatedBy   pgtype.UUID `json:"created_by"`
}

func (q *Queries) CreateWorkspaceMcpServer(ctx context.Context, arg CreateWorkspaceMcpServerParams) (WorkspaceMcpServer, error) {
	row := q.db.QueryRow(ctx, createWorkspaceMcpServer,
		arg.WorkspaceID,
		arg.Name,
		arg.Config,
		arg.CreatedBy,
	)
	var i WorkspaceMcpServer
	err := row.Scan(
		&i.ID,
		&i.WorkspaceID,
		&i.Name,
		&i.Config,
		&i.CreatedBy,
		&i.CreatedAt,
		&i.UpdatedAt,
	)
	return i, err
}

const deleteAgentMcpServersByServer = `-- name: DeleteAgentMcpServersByServer :exec
DELETE FROM agent_mcp_server WHERE server_id = $1
`

// Bindings carry no FK, so removing a library entry must sweep them explicitly
// in the same transaction as the delete.
func (q *Queries) DeleteAgentMcpServersByServer(ctx context.Context, serverID pgtype.UUID) error {
	_, err := q.db.Exec(ctx, deleteAgentMcpServersByServer, serverID)
	return err
}

const deleteWorkspaceMcpServer = `-- name: DeleteWorkspaceMcpServer :execrows
DELETE FROM workspace_mcp_server
WHERE id = $1 AND workspace_id = $2
`

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

func (q *Queries) DeleteWorkspaceMcpServer(ctx context.Context, arg DeleteWorkspaceMcpServerParams) (int64, error) {
	result, err := q.db.Exec(ctx, deleteWorkspaceMcpServer, arg.ID, arg.WorkspaceID)
	if err != nil {
		return 0, err
	}
	return result.RowsAffected(), nil
}

const getWorkspaceMcpServer = `-- name: GetWorkspaceMcpServer :one
SELECT id, workspace_id, name, config, created_by, created_at, updated_at FROM workspace_mcp_server
WHERE id = $1 AND workspace_id = $2
`

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

func (q *Queries) GetWorkspaceMcpServer(ctx context.Context, arg GetWorkspaceMcpServerParams) (WorkspaceMcpServer, error) {
	row := q.db.QueryRow(ctx, getWorkspaceMcpServer, arg.ID, arg.WorkspaceID)
	var i WorkspaceMcpServer
	err := row.Scan(
		&i.ID,
		&i.WorkspaceID,
		&i.Name,
		&i.Config,
		&i.CreatedBy,
		&i.CreatedAt,
		&i.UpdatedAt,
	)
	return i, err
}

const listAgentMcpServers = `-- name: ListAgentMcpServers :many
SELECT s.id, s.workspace_id, s.name, s.config, s.created_at, s.updated_at, ams.enabled
FROM workspace_mcp_server s
JOIN agent_mcp_server ams ON ams.server_id = s.id
WHERE ams.agent_id = $1
ORDER BY s.name ASC
`

type ListAgentMcpServersRow struct {
	ID          pgtype.UUID        `json:"id"`
	WorkspaceID pgtype.UUID        `json:"workspace_id"`
	Name        string             `json:"name"`
	Config      []byte             `json:"config"`
	CreatedAt   pgtype.Timestamptz `json:"created_at"`
	UpdatedAt   pgtype.Timestamptz `json:"updated_at"`
	Enabled     bool               `json:"enabled"`
}

// Every workspace server bound to this agent, enabled or not, for the agent
// settings list. `enabled` comes from the binding.
func (q *Queries) ListAgentMcpServers(ctx context.Context, agentID pgtype.UUID) ([]ListAgentMcpServersRow, error) {
	rows, err := q.db.Query(ctx, listAgentMcpServers, agentID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	items := []ListAgentMcpServersRow{}
	for rows.Next() {
		var i ListAgentMcpServersRow
		if err := rows.Scan(
			&i.ID,
			&i.WorkspaceID,
			&i.Name,
			&i.Config,
			&i.CreatedAt,
			&i.UpdatedAt,
			&i.Enabled,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const listEnabledAgentMcpServers = `-- name: ListEnabledAgentMcpServers :many
SELECT s.name, s.config
FROM workspace_mcp_server s
JOIN agent_mcp_server ams ON ams.server_id = s.id
WHERE ams.agent_id = $1 AND ams.enabled = TRUE
ORDER BY s.name ASC
`

type ListEnabledAgentMcpServersRow struct {
	Name   string `json:"name"`
	Config []byte `json:"config"`
}

// Claim path: only bound AND enabled servers reach the runtime. An unbound
// workspace server is invisible to this agent — creating one gives it to
// nobody until someone adds it here.
func (q *Queries) ListEnabledAgentMcpServers(ctx context.Context, agentID pgtype.UUID) ([]ListEnabledAgentMcpServersRow, error) {
	rows, err := q.db.Query(ctx, listEnabledAgentMcpServers, agentID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	items := []ListEnabledAgentMcpServersRow{}
	for rows.Next() {
		var i ListEnabledAgentMcpServersRow
		if err := rows.Scan(&i.Name, &i.Config); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const listWorkspaceMcpServers = `-- name: ListWorkspaceMcpServers :many
SELECT id, workspace_id, name, config, created_by, created_at, updated_at FROM workspace_mcp_server
WHERE workspace_id = $1
ORDER BY name ASC
`

// The workspace's MCP library. Returns `config` because the callers that need
// it (claim assembly, the write path's read-modify-write) run server-side; the
// HTTP layer projects it down to the non-secret inventory.
func (q *Queries) ListWorkspaceMcpServers(ctx context.Context, workspaceID pgtype.UUID) ([]WorkspaceMcpServer, error) {
	rows, err := q.db.Query(ctx, listWorkspaceMcpServers, workspaceID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	items := []WorkspaceMcpServer{}
	for rows.Next() {
		var i WorkspaceMcpServer
		if err := rows.Scan(
			&i.ID,
			&i.WorkspaceID,
			&i.Name,
			&i.Config,
			&i.CreatedBy,
			&i.CreatedAt,
			&i.UpdatedAt,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const lockWorkspaceMcpServerForShare = `-- name: LockWorkspaceMcpServerForShare :one
SELECT id FROM workspace_mcp_server
WHERE id = $1 AND workspace_id = $2
FOR SHARE
`

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

// Taken by the assignment writer before it inserts. A shared row lock
// conflicts with the exclusive lock DeleteWorkspaceMcpServer takes, so an
// assignment can never land in the window between that delete sweeping the
// bindings and committing — the junction has no FK to catch the orphan.
func (q *Queries) LockWorkspaceMcpServerForShare(ctx context.Context, arg LockWorkspaceMcpServerForShareParams) (pgtype.UUID, error) {
	row := q.db.QueryRow(ctx, lockWorkspaceMcpServerForShare, arg.ID, arg.WorkspaceID)
	var id pgtype.UUID
	err := row.Scan(&id)
	return id, err
}

const lockWorkspaceMcpServerForUpdate = `-- name: LockWorkspaceMcpServerForUpdate :one
SELECT id FROM workspace_mcp_server
WHERE id = $1 AND workspace_id = $2
FOR UPDATE
`

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

// The delete half of the same protocol: take the row exclusively first, so a
// concurrent assignment either lands before this transaction (and is swept) or
// waits and then finds the server gone.
func (q *Queries) LockWorkspaceMcpServerForUpdate(ctx context.Context, arg LockWorkspaceMcpServerForUpdateParams) (pgtype.UUID, error) {
	row := q.db.QueryRow(ctx, lockWorkspaceMcpServerForUpdate, arg.ID, arg.WorkspaceID)
	var id pgtype.UUID
	err := row.Scan(&id)
	return id, err
}

const removeAgentMcpServer = `-- name: RemoveAgentMcpServer :execrows
DELETE FROM agent_mcp_server
WHERE agent_id = $1 AND server_id = $2
`

type RemoveAgentMcpServerParams struct {
	AgentID  pgtype.UUID `json:"agent_id"`
	ServerID pgtype.UUID `json:"server_id"`
}

func (q *Queries) RemoveAgentMcpServer(ctx context.Context, arg RemoveAgentMcpServerParams) (int64, error) {
	result, err := q.db.Exec(ctx, removeAgentMcpServer, arg.AgentID, arg.ServerID)
	if err != nil {
		return 0, err
	}
	return result.RowsAffected(), nil
}

const setAgentMcpServerEnabled = `-- name: SetAgentMcpServerEnabled :execrows
UPDATE agent_mcp_server
SET enabled = $3
WHERE agent_id = $1 AND server_id = $2
`

type SetAgentMcpServerEnabledParams struct {
	AgentID  pgtype.UUID `json:"agent_id"`
	ServerID pgtype.UUID `json:"server_id"`
	Enabled  bool        `json:"enabled"`
}

func (q *Queries) SetAgentMcpServerEnabled(ctx context.Context, arg SetAgentMcpServerEnabledParams) (int64, error) {
	result, err := q.db.Exec(ctx, setAgentMcpServerEnabled, arg.AgentID, arg.ServerID, arg.Enabled)
	if err != nil {
		return 0, err
	}
	return result.RowsAffected(), nil
}

const updateWorkspaceMcpServer = `-- name: UpdateWorkspaceMcpServer :one
UPDATE workspace_mcp_server SET
    name = COALESCE($3, name),
    config = COALESCE($4, config),
    updated_at = now()
WHERE id = $1 AND workspace_id = $2
RETURNING id, workspace_id, name, config, created_by, created_at, updated_at
`

type UpdateWorkspaceMcpServerParams struct {
	ID          pgtype.UUID `json:"id"`
	WorkspaceID pgtype.UUID `json:"workspace_id"`
	Name        pgtype.Text `json:"name"`
	Config      []byte      `json:"config"`
}

// Full replace of one entry. The name can change here (unlike the previous
// document model) because bindings key off the id, so a rename cannot orphan
// the agents that use it.
func (q *Queries) UpdateWorkspaceMcpServer(ctx context.Context, arg UpdateWorkspaceMcpServerParams) (WorkspaceMcpServer, error) {
	row := q.db.QueryRow(ctx, updateWorkspaceMcpServer,
		arg.ID,
		arg.WorkspaceID,
		arg.Name,
		arg.Config,
	)
	var i WorkspaceMcpServer
	err := row.Scan(
		&i.ID,
		&i.WorkspaceID,
		&i.Name,
		&i.Config,
		&i.CreatedBy,
		&i.CreatedAt,
		&i.UpdatedAt,
	)
	return i, err
}