mcp

type AwaitApprovalInput struct {
	ExecutionID    string `json:"execution_id" jsonschema:"the execution_id returned by query or describe when the status was not ok"`
	TimeoutSeconds int    `` /* 173-byte string literal not displayed */
}

type Caller struct {
	User   *store.User
	APIKey string
}

type ColumnInfo struct {
	Name     string `json:"name"`
	Type     string `json:"type"`
	Nullable bool   `json:"nullable"`
	Default  string `json:"default,omitempty"`
}

type DatabaseInfo struct {
	Name             string `json:"name" jsonschema:"the name to pass to query and describe"`
	Description      string `json:"description,omitempty"`
	Protocol         string `json:"protocol"`
	Supported        bool   `json:"supported" jsonschema:"false when this dbbat version cannot run statements against this protocol yet"`
	GrantExpiresAt   string `json:"grant_expires_at" jsonschema:"RFC3339 instant after which the grant stops working mid-session"`
	ReadOnly         bool   `json:"read_only"`
	BlockDDL         bool   `json:"block_ddl"`
	BlockCopy        bool   `json:"block_copy"`
	ApprovalPatterns int    `` /* 134-byte string literal not displayed */
	MaxQueries       *int64 `json:"max_queries,omitempty"`
	QueriesUsed      int64  `json:"queries_used"`
	MaxBytes         *int64 `json:"max_bytes_transferred,omitempty"`
	BytesUsed        int64  `json:"bytes_transferred"`
}

type Deps struct {
	Store  GrantStore
	Logger *slog.Logger
	// Broker resolves the shared event broker at call time. It is a function
	// because the process wiring installs the shared broker on the API server
	// *after* construction (Server.SetEventPlumbing), and the MCP layer must
	// see that instance rather than the placeholder it was built with.
	Broker func() *events.Broker
	// Executor runs statements through the loopback proxy listeners.
	Executor Executor
	// GraceWindow / AwaitWindow override the defaults; zero means default.
	// Test seams, and the knobs an operator would want first if the shape
	// ever needs tuning.
	GraceWindow time.Duration
	AwaitWindow time.Duration
}

type DescribeInput struct {
	Database string `json:"database" jsonschema:"database name, as returned by list_databases"`
	Table    string `json:"table,omitempty" jsonschema:"table (MongoDB: collection) to describe. Omit to list the database's tables instead"`
	Schema   string `json:"schema,omitempty" jsonschema:"PostgreSQL schema to disambiguate a table name present in several schemas"`
}

type DescribeOutput struct {
	Status      string       `json:"status"`
	Database    string       `json:"database"`
	Protocol    string       `json:"protocol"`
	Tables      []TableInfo  `json:"tables,omitempty"`
	Table       string       `json:"table,omitempty"`
	Columns     []ColumnInfo `json:"columns,omitempty"`
	Truncated   bool         `json:"truncated" jsonschema:"true when the database has more tables or columns than one call returns"`
	ExecutionID string       `json:"execution_id,omitempty"`
	QueryUID    string       `json:"query_uid,omitempty"`
	Message     string       `json:"message,omitempty"`
}

type ExecRequest struct {
	// Protocol is the target's wire protocol; it selects the loopback client.
	Protocol string
	// Database is the **dbbat server name**, which is what every proxy resolves
	// the target from (PostgreSQL's startup `database` parameter, MySQL's
	// schema name, Oracle's SERVICE_NAME, SQL Server's LOGIN7 database and
	// MongoDB's authSource are all looked up with GetServerByName).
	Database string
	// UpstreamDatabase is the database name *on the target server* — the
	// `database_name` column of the dbbat row.
	//
	// Only the MongoDB client needs it, and only because a MongoDB command
	// carries its own `$db` inside the message, which the proxy forwards
	// verbatim: a command addressed to the dbbat entry's name would reach the
	// upstream naming a database that does not exist there. Every other
	// protocol carries the database once, at login, where the dbbat name is the
	// right one.
	UpstreamDatabase string
	// Username is the API key owner's username. The proxies refuse a key
	// whose owner does not match the username on the wire.
	Username string
	// APIKey is the caller's `dbb_` key, used verbatim as the connection
	// password — the documented way a key holder authenticates to a proxy.
	APIKey string
	// SQL is the statement, passed through untouched. Rewriting it would
	// falsify what /queries records and what approval patterns match.
	SQL string
	// Params are bind parameters. Non-empty forces the prepared-statement
	// path on both protocols, which is also what an operator wants for
	// untrusted values.
	Params []any
	// MaxRows caps the rows returned to the agent. Already clamped by the
	// caller; the executor treats it as authoritative.
	MaxRows int
}

type Executor interface {
	Execute(ctx context.Context, req ExecRequest) (*QueryResult, error)
}

type GrantStore interface {
	ListGrants(ctx context.Context, filter store.GrantFilter) ([]store.Grant, error)
	GetServerByUID(ctx context.Context, uid uuid.UUID) (*store.Server, error)
	// ListServerGroupMemberUIDs expands a group-bound grant into the servers
	// it currently covers — a grant no longer names a single database.
	ListServerGroupMemberUIDs(ctx context.Context, groupUID uuid.UUID) ([]uuid.UUID, error)
}

type ListDatabasesInput struct{}

type ListDatabasesOutput struct {
	Databases []DatabaseInfo `json:"databases"`
}

type LoopbackExecutor struct {
	// contains filtered or unexported fields
}

type LoopbackListeners struct {
	PostgreSQL string
	MySQL      string
	Oracle     string
	MongoDB    string
	MSSQL      string
}

type QueryInput struct {
	Database string `json:"database" jsonschema:"database name, as returned by list_databases"`
	SQL      string `` /* 155-byte string literal not displayed */
	Params   []any  `` /* 187-byte string literal not displayed */
	MaxRows  int    `` /* 164-byte string literal not displayed */
}

type QueryOutput struct {
	Status          string           `` /* 151-byte string literal not displayed */
	Database        string           `json:"database"`
	Columns         []string         `json:"columns,omitempty"`
	Rows            []map[string]any `json:"rows,omitempty" jsonschema:"result rows keyed by column name, in result order"`
	RowCount        int              `json:"row_count"`
	Truncated       bool             `json:"truncated" jsonschema:"true when the statement produced more rows than max_rows"`
	MaxRows         int              `json:"max_rows" jsonschema:"the cap actually applied, after server-side clamping"`
	RowsAffected    *int64           `json:"rows_affected,omitempty"`
	DurationMs      int64            `json:"duration_ms"`
	ExecutionID     string           `json:"execution_id,omitempty" jsonschema:"pass this to await_approval while the status is not ok"`
	QueryUID        string           `json:"query_uid,omitempty" jsonschema:"the dbbat query a human is being asked to approve, as shown in the dbbat UI and Slack"`
	ApprovalPattern string           `json:"approval_pattern,omitempty" jsonschema:"the grant pattern that matched and caused the hold"`
	Message         string           `json:"message,omitempty"`
}

type QueryResult struct {
	// Columns are the result columns in wire order, de-duplicated so Rows can
	// key by name.
	Columns []string
	// Rows are the (capped) result rows as column-name → value maps.
	Rows []map[string]any
	// Truncated reports that the statement produced more rows than MaxRows.
	Truncated bool
	// RowsAffected is set for statements that report it (INSERT/UPDATE/…).
	RowsAffected *int64
}

type Server struct {
	// contains filtered or unexported fields
}

type TableInfo struct {
	Schema string `json:"schema,omitempty"`
	Name   string `json:"name"`
}