scripthttp

type AuditRecorder interface {
	Log(ctx context.Context, event audit.Event) error
}

type ConnectionChoice struct {
	Name string `json:"name" example:"warehouse"`
	// Kind is the toolkit serving it.
	Kind        string `json:"kind,omitempty" example:"trino"`
	Description string `json:"description,omitempty" example:"Production Trino cluster"`
}

type ConnectionEnumerator func(ctx context.Context, caller ConnectionScope) []ConnectionChoice

type ConnectionScope struct {
	// Persona is the caller's resolved persona, whose connections rules decide
	// what they may reach. An unresolved persona reaches nothing, which is the
	// same fail-closed default the authorizer applies to a tool call.
	Persona string
	// Unrestricted lifts the persona boundary for an administrator, whose reach
	// over this surface is unrestricted by design.
	Unrestricted bool
}

type ContractReader interface {
	Contract(ctx context.Context, id string) (*script.Contract, error)
}

type Deps struct {
	Scripts  script.Store
	Versions script.VersionStore
	// Schedules is the cadence store. Nil leaves the schedule routes unmounted,
	// which is the honest shape for a deployment that cannot keep a schedule.
	Schedules script.ScheduleStore

	// Runs is the run history. Nil leaves the portal run routes unmounted: a
	// deployment that keeps no runs has no history to show.
	Runs script.RunStore
	// Contracts composes one script's contract document for the portal detail
	// route. Nil leaves that route unmounted.
	Contracts ContractReader
	// LatestRuns reports each script's most recent run for the portal listing.
	// Nil leaves the listing's last-run column empty rather than unmounting it.
	LatestRuns LatestRunReader

	// States holds each script's one object of state (#1537): what a run
	// reads as run.state and saves with platform.save_state. Nil leaves the
	// state routes unmounted and a draft reading {}, which is the shape of a
	// deployment that keeps no state.
	States script.StateStore

	// DryRuns records and resolves the accounts of draft executions (#1364).
	// Nil runs drafts without keeping an account of them, which leaves every
	// version reading as one nobody dry-ran — the state before the account
	// existed — rather than failing the run.
	DryRuns script.DryRunStore

	// Drafts executes a draft under the calling person's own identity. Nil
	// leaves the dry-run route unmounted; validate needs nothing but the
	// source and stays either way.
	Drafts DraftRunner

	// Destinations is the deployment's declared bucket destination set, which
	// validate and dry-run check a source's named destinations against so an
	// undeclared one is reported before the script's queries run (#1415).
	// Empty means the portal is the only place a script may write, which is
	// what the runtime already reports.
	Destinations []script.Destination

	// Connections enumerates the connections the portal caller's own persona
	// reaches, which a connection-typed parameter is chosen from (#1361). Nil
	// leaves the choices route unmounted.
	Connections ConnectionEnumerator

	// Audit records administrative script writes — today the owner transfer
	// (#1404). Nil leaves the transfer working and unrecorded, which is what a
	// deployment with no audit store has for every other write too.
	Audit AuditRecorder

	// AdminEmail returns the authenticated administrator's email, recorded as
	// the author of an admin-made edit.
	AdminEmail func(r *http.Request) string
	// PortalUser resolves the authenticated portal caller, or nil when the
	// request carries no user. Nil leaves the portal routes unmounted, which is
	// what the admin surface passes.
	PortalUser func(r *http.Request) *PortalIdentity

	// Produced lists everything a script has written across every run (#1569).
	// Nil leaves that route unmounted, which is the shape of a deployment that
	// records no producers.
	Produced ProducedReader
}

type DraftRunner interface {
	Run(ctx context.Context, req scriptdraft.Request) (*scriptdraft.Outcome, error)
}

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

type LatestRunReader interface {
	LatestRuns(ctx context.Context, scriptIDs []string) (map[string]script.Run, error)
}

type PortalIdentity struct {
	UserID  string
	Email   string
	Persona string
	IsAdmin bool
	// Roles is the authority this caller holds. It is recorded on any version
	// they author (#1307): a run of that version presents exactly these roles,
	// which is what keeps a script from holding more access than the person
	// who wrote it.
	Roles []string
	// AuthType is HOW this caller was authenticated. It matters because the
	// dry-run route opens a session on their behalf (#1364): that session must
	// present the authentication the request actually arrived with rather than
	// a kind no authenticator issues.
	AuthType string
}

type ProducedReader interface {
	Produced(ctx context.Context, scriptID string, limit int) ([]producedview.Item, error)
}