Lite Workspace API — Phase 1 Plan

Add an internal configuration structure to the Coderd method that fetches a
workspace with its related data (workspaceData /workspaceBuildsData), thread
it down to the SQL query call sites, and skip ("squash") queries that are not
requested. Server-internal only. No HTTP query-string parsing (Phase 2) and no
wsrelated struct tags or field nil-ing (Phase 3).

Scope

• In: config struct mapping the RFC related-data hierarchy; threading through
  workspaceData and workspaceBuildsData; gating every related-data query;
  comprehensive unit tests with a mocked database.Store (gomock/dbmock).
• Out: HTTP include_related parsing, codersdk changes, wsrelated tags, docs
  autogen, and changing convertWorkspaces skip-on-missing-data behavior. All
  existing callers pass an "include all" config, so Phase 1 is a behavior-
  preserving refactor.

Design

New file coderd/wsrelateddata.go with a pointer tree that mirrors the RFC
hierarchy. Branch nodes are pointers (present when non-nil); leaf nodes are
bools. Because a child cannot be expressed without its parent, the RFC
"includes all ancestors" rule is a structural invariant of the type: an illegal
selection is unrepresentable, so no normalization pass exists or is needed.

type workspaceRelated struct {
    Template    bool
    LatestBuild *latestBuildRelated
}
type latestBuildRelated struct {
    Job             *jobRelated
    Resources       *resourcesRelated
    TemplateVersion bool
}
type jobRelated struct{ QueuePosition bool }
type resourcesRelated struct {
    Metadata bool
    Agents   *agentsRelated
}
type agentsRelated struct {
    Apps       *appsRelated
    Scripts    bool
    LogSources bool
}
type appsRelated struct{ Statuses bool }

Helpers:

• allWorkspaceRelated() / allLatestBuildRelated() construct a fully
  populated tree. Passed by all current callers so behavior is unchanged.
• Zero value (nil subtree) includes nothing but the workspace itself.
• (*latestBuildRelated).appStatuses() is a nil-safe accessor for the deep
  apps.statuses leaf so call sites descend the tree without a guard chain.

Rationale for the pointer tree over a flat struct plus withAncestors(): the
invariant holds by construction (illegal state is unrepresentable) instead of
relying on a normalization step a caller must remember. workspaceBuildsData
takes the *latestBuildRelated subtree directly.

Query gating

workspaceData(ctx, workspaces, cfg):

• GetTemplatesWithFilter gated on Template.
• GetLatestWorkspaceBuildsByWorkspaceIDs gated on LatestBuild; when off, skip
  workspaceBuildsData entirely (empty builds).
• GetLatestWorkspaceAppStatusesByWorkspaceIDs (workspace-level LatestAppStatus)
  gated on AppStatuses.

workspaceBuildsData(ctx, builds, cfg) gates each stage:

• jobs (GetProvisionerJobsByIDsWithQueuePosition) + eligible provisioner
  daemons gated on Job. Only one job query exists and it always computes the
  queue position, so QueuePosition does not gate a separate query yet; it is
  modeled for hierarchy/Phase 2 completeness. A cheaper job query without the
  window-function ranking is a worthwhile follow-up but is out of scope for a
  simple Phase 1 (needs new SQL + sqlc gen).
• resources gated on Resources; metadata on Metadata; agents on Agents;
  apps on Apps; app statuses on AppStatuses; scripts on Scripts; log
  sources on LogSources; template versions on TemplateVersion.

Downstream convertWorkspaceBuilds already tolerates empty slices, so squashing
queries yields zero/nil fields without extra work.

Testing (comprehensive, mocked database.Store)

Internal tests (coderd/wsrelateddata_internal_test.go) build
&API{Options: &Options{Database: dbmock.NewMockStore(ctrl)}} and call
workspaceData directly. gomock is strict, so setting EXPECT only on permitted
queries proves the rest are squashed.

Cases: include-all (every query runs); zero value (no related queries run);
each single node (template only, latest_build only, job, resources, metadata,
agents, apps, statuses, scripts, log_sources, template_version, workspace-level
app statuses); the empty-resources short-circuit; and the constructors plus the
nil-safe appStatuses() accessor at every depth.

Steps

1. Add coderd/wsrelateddata.go (selection tree, constructors, appStatuses).
2. Thread the selection through workspaceData and workspaceBuildsData; gate
   queries by descending the tree.
3. Update the callers to pass allWorkspaceRelated() / allLatestBuildRelated().
4. Add unit tests; run make fmt, make lint, targeted go test.

Resolved decisions

1. Pointer tree over a flat struct + normalizer, so the ancestor rule is a
   structural invariant.
2. Cheaper queue-position-free job query deferred to a follow-up.