beads/internal/httpclient/batchcreator.go
Julian Knutsen c4e667cb14
feat(http): list/show counts/dep tree/ping over http, the advertised external-dependency policy, one-lookup not-found (S6b/S6c/S6d) (#7471)
* feat(http): serve list/show counts/dep tree/ping, close+reopen under a session, one-lookup not-found (S6b/S6c/S6d)

S6c. The external-dependency decorator rebuilt its role views from the
legacy DoltStorage seam (storereader over itself, IsBlocked,
GetDependencyTree, ClaimReadyIssue), which a remote store only partly
serves: `bd list`/`bd children` refused on the SearchIssuesWithCounts stub,
`bd show --json` printed zero counts, the default `bd dep tree` refused,
`bd ready --claim` and `bd close` of an externally blocked issue reached
unsupported paths. For a storage.RemoteBackendStore each view now passes the
inner role through and lays the policy over it in role terms
(externaldeps/remote_roles.go): ready reads and the ready claim exclude the
workspace-wide blocked set over a widened window; per-issue checks (claim,
close, batch close, list annotations, tree leaves) read only the named
issues' edges through EdgeReader instead of every edge in the workspace. A
server advertising policy.external_dependencies (MC's does) gets a plain
passthrough. `bd ping` uses a new storage.Pinger, which the http store
answers with its authenticated context read.

S6d. A store reporting storage.CallerAttributionLimitedStore (http) cannot
carry a Provenance label or a patch's closed_by_session. The library still
refuses both; the CLI omits them where nothing is lost: `bd reopen`'s fixed
"bd: reopen <id>" label (the server labels the same entry), and the
closed_by_session of `bd update -s closed` (attribution only, usually the
ambient CLAUDE_SESSION_ID; an explicit --session prints a notice; `bd close`
still records it). See cmd/bd/remote_backend.go.

S6b. utils.ExactIDLookupStore: the resolver stops at exact lookups for a
store with no substring search, so a missing prefixed id is a not-found
(beadserrors.ErrNotFound, "no issue found matching") after one getIssue.
The general resolver no longer repeats an identical normalized probe. The
http SearchIssueIDs answers D11's partial-id refusal, which now unwraps to
ErrNotFound. Contributor auto-routing for a remote workspace reads local
config only, so the not-found fallback pays no settings round trip.
`bd update <absent> --claim` (gc's hook claim) answers a gc-classifiable
not-found in at most two requests.

Served e2e (backend/http/e2e_remote_roles_test.go): every gc list shape and
`bd children` against embedded, `show --json` count parity, default dep
tree parity, external blocking still enforced, close/reopen under
CLAUDE_SESSION_ID, missing-id request counts, absent-id claim against the
current server and the MC handshake mask, policy passthrough under the MC
mask, ping.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* test(externaldeps): role-level remote reader and claimer cases

bd ready and bd update --claim reach the policy through the legacy seam and
the lifecycle guard, so the remote Reader.Ready exclusion and the remote
Claimer guard (what bd serve and library callers reach) are pinned at the
role level with a fake remote store.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* feat(http): bd serve advertises policy.external_dependencies; clients pass through

bd serve composes every ready, claim, claim-next, close, blocking and tree
role through the external-dependency policy, but never said so. Every
client therefore ran the policy a second time, with the CLIENT machine's
external-project config, and claim-next became a non-atomic read-then-claim
loop on the client.

The server now advertises the token exactly when the roles it serves were
composed through the policy: httpapi.Config.ExternalDependencyPolicy, which
bd serve derives from its actual chain (externaldeps.Applied for the store
arm, externaldeps.AppliedToProvider for the provider arm). A server handed
raw roles still withholds it, so the token stays truthful.

Against a server that advertises it, every remote role view hands the
request to the server's own role untouched: no client validation, no edge
reads, claim-next is the server's one atomic call, and the ready count is
the server's countReadyWork (new remoteReadyCounter). The client-side
policy remains only for servers that do not advertise the token.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(create): default created_by to the request's actor in the create role

created_by was stamped in two front doors and never in the library: the
CLI (creationActorStamp, with a remote-workspace special case) and the
three httpapi create handlers. A library caller of Lifecycle.Create or
BatchCreator with an empty CreatedBy stored "" locally and the actor over
http.

PreparePublicCreateRequest, which every create shape prepares through
(Lifecycle.Create, BatchCreator items, batch-apply create items), now
defaults an empty CreatedBy to request.Actor; an explicit value is kept.
The handlers no longer stamp, `bd create` and the state event create pass
only the actor, and creationActorStamp/isRemoteBackendWorkspace are gone.

The CLI sites that still create through the raw CreateIssue seam (swarm,
todo, gate, the create form) keep stamping currentActor(): that seam is
shared with import, where defaulting would re-attribute imported rows, and
the http store refuses it anyway, so the remote special case was never
reachable there.

Conformance: the lifecycle-create, batch-creator and batch-apply contracts
now pin created_by == actor for an item that names none, on every leg.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(httpclient): GetIssue answers a miss with storage.ErrNotFound, like the local stores

The http store's raw GetIssue answered a missing id with (nil, nil), where
DoltStore and the embedded store return a wrapped storage.ErrNotFound. A
caller written against the backend contract read the http miss as a hit:
`bd create --graph` refused every explicit-id plan over http (patched in
cmd/bd on feat/http-mc-corpus; that workaround is reverted there).

GetIssue now returns the miss (and the empty id) as storage.ErrNotFound,
spelled as issueops.GetIssueInTx spells it. GetLabels, which reads through
GetIssue, keeps the local read's "no labels" answer for a missing id; the
`bd list --parent` walk reads the typed miss as "parent issue not found".

The served bridge test now holds the local reference store and the http
store to the same miss: ErrNotFound with the same text.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* test(createbatchequiv): re-record the apply golden for the created_by default

c2866ea7fe made the create role default an empty CreatedBy to the
request's actor, so every create item of the apply scenario's batch
(actor "apply-writer") now stores created_by "apply-writer" instead of "".
TestCreateBatchFastPathsMatchPerRow_*/apply compared the stored rows to a
digest recorded before that change and failed on exactly the three tables
the column reaches: issues and wisps (the row) and events (the update
event's old-value snapshot). Fast and per-row bodies still agree; the
batch-apply conformance contract pins the same value.

Bisected with bazel: passes at be92efe40f's integ twin 696f7acc8e, fails
from the created_by commit on. Only apply.json's three digests move.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* style: gofmt ledger.go and the externaldeps remote-roles test

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(cmd/bd): bd create reads routing settings local-only on a remote backend too

determineAutoRoutedRepoPath skipped a remote backend's settings document
(routing targets are local paths that one shared document cannot name for
every client), but getRoutingConfigValue, which `bd create` and
migrate-personal read routing.* and contributor.* through, still asked it.
The same workspace could route a create one way and a lookup another, and
every create paid a settings round trip per key.

Both now go through routingSettingsStore: nil for a remote backend, so
routing comes from config.yaml / the environment only there, and a local
store is still consulted. A unit test holds both reads to the rule with a
store that counts settings reads.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(cmd/bd): say so when update -s closed drops an ambient CLAUDE_SESSION_ID

Over http `bd update -s closed` cannot carry closed_by_session, so the CLI
drops it rather than refusing the close. An explicit --session printed a
notice; the ambient CLAUDE_SESSION_ID every agent under Claude Code exports
was dropped without a word, a silent data difference from a local backend
(the served corpus's mc-update-meta-status-closed). The drop is now named
on stderr in both cases, once per command, pointing at `bd close`, whose
wire operation records the session. The served e2e asserts the notice.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* test(backend/http): hold bd list --limit 2 to each side's own unlimited order

TestE2E_ListWithGCFiltersMatchesEmbedded compared the --limit 2 rows of
the served and embedded workspaces as sets. The seed has four P2 rows, so
the limit cuts a priority tie whose created_at order differs between two
workspaces seeded seconds apart: a test-only flake, the order itself being
total. Each side's two rows must now be, in order, the first two of that
same side's --limit 0 listing; the unlimited listings are still compared
across sides by the shape loop.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* test: unit-tier pins for the created_by default, the policy token and the GetIssue miss

Three review mutations were caught only by a heavier tier (the uow
conformance legs, the served httpclient tier) or by one package's test
alone. Each now has a unit test where its rule lives:

- issueops: PreparePublicCreateRequest defaults an empty CreatedBy to the
  actor and keeps an explicit one, without mutating the caller's request.
- externaldeps: the policy layer AppliedToProvider finds becomes the
  handshake's policy.external_dependencies through httpapi.Listen, the
  composition bd serve performs, and a raw provider's handshake lacks it.
- httpclient (no embedded engine): GetIssue over the real wire client
  against a stub server answers a 404 not_found, and the empty id without
  dialing, as storage.ErrNotFound spelled like the local stores.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* docs(changelog): S6b/c/d entries match the code

The S6 entry still said `bd create` suppresses created_by on a remote
workspace and that the external-dependency policy runs client-side. Since
S6b/c/d, created_by defaults to the actor in the library on every backend,
and every bd serve composed through the policy advertises
policy.external_dependencies, so clients pass those operations through;
the client-side policy (now in role terms) runs only against a server that
does not advertise it.

New entries: the advertised policy token, bd ping over http, the created_by
library default, closed_by_session dropped by an http `bd update -s closed`
(with a notice, typed or ambient), reopen without a Provenance label over
http, local-only routing.* / contributor.* on a remote backend, GetIssue's
miss as storage.ErrNotFound, and list/children/show counts/dep tree over
http.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(externaldeps): keep S6's list --ready, --claim-next refusal and lost-race error on the S6c composition

The re-adopted S6 head (#7288) carries the review fixup's remote role
composition; S6c replaces it with its own (rolesAreRemote, the widened
ready window, the policy passthrough). Two behaviours S6 shipped and its
reviews pinned would otherwise go:

- bd close --claim-next against a server that does not apply the policy
  is refused whole, before anything is read or closed, with "the served
  batch close cannot carry a next claim, so nothing was closed; close
  without --claim-next, then run `bd ready --claim`". S6c passed the batch
  to the http closer, whose W-CloseBatchRequest.ClaimNext refusal drops the
  remedy, so TestE2E_BDOverHTTP's two refuseClaimNext steps went red. A
  request invalid on every backend is still ErrValidation first, and a
  server that applies the policy still gets the request untouched.
- remoteReadyClaimer.ClaimNext reports a page on which every candidate was
  lost to another actor as "claim ready: lost N races ...", not as the
  empty answer that means there is no work.

- `bd list --ready` (List with ReadyFlag) is answered by the policy
  store's own reader over the served ready reads, as S6 does. S6c passed
  it to the served listing, which cannot carry ReadyFlag (httpclient
  ledger row E-ListRequest.ReadyFlag), so it exited 1 over http with or
  without external refs; TestE2E_BDOverHTTP and
  TestServedRolesKeepTheExternalDependencyPolicy were red on it.
  TestRemoteReaderAnswersAReadyListingWithoutTheWireFlag pins it, with the
  fake's served List refusing ReadyFlag as the wire does.

S6's composition tests now run against S6c as remote_roles_composition_test.go.
Their fake serves Ready the way a server does (the S6 composition read
ready work through the legacy policy reader instead), and two call logs
gain that Ready. TestRemoteBatchCloserRefusesANextClaim,
TestRemoteBatchCloserValidatesANextClaimFirst and
TestRemoteReadyClaimerReportsLostRaces were red on S6c before this change.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(externaldeps): unassigned claim-next and fail-closed close reads

Review fixes for the S6c composition against a server that does not
advertise policy.external_dependencies: the two majors of review
attempt 1, plus the minors on the same code.

- ReadyClaimer: the composed claim-next reads only open, unassigned
  ready rows (Unassigned=true, Assignee cleared), the candidates the
  local ClaimReadyIssueInTx selects. A row another actor holds, or one
  already assigned to the caller, is no longer taken or counted as a
  lost race. Each pass reads 25 candidates past the blocked rows, as
  httpclient's composed claim does, and a full window lost end to end
  is read once more: claimed rows leave the unassigned set. Only a
  claim that tried candidates and won none is an error.
- BatchCloser: an externally blocked item travels to the server only
  when its status read finds it closed or not found (liveRefusal). Any
  other read error is that item's outcome, so a transient or auth
  failure no longer forwards a refused close to a server that will not
  refuse it.
- TreeWalker: a failed capability probe renders the external leaves
  over the walked tree instead of failing a walk the server already
  answered. appendTreeExternalReferences skips an id the tree holds,
  so an enforcing server's own leaves are not doubled.
- remoteEdges names each anchor once and skips an empty one, which the
  http EdgeReader refuses with ErrValidation.

The composition fakes now honor Unassigned/Assignee as
workapi.BuildReadyFilter does, model a rival claim landing first and a
failing GetIssue, and refuse an empty edge anchor as httpclient does.
New: TestRemoteReadyClaimerTakesOnlyUnassignedWork,
TestRemoteReadyClaimerWalksAContendedFront,
TestRemoteBatchCloserAnswersAFailedReadWithIt,
TestRemoteEdgesNamesEachAnchorOnce, and the probe-failure cases of
TestRemoteTreeWalkerAddsExternalLeaves. Each is red with its fix
reverted.

From review attempt 2, three nearby cleanups:

- TestServedRolesKeepTheExternalDependencyPolicy seeds open rows held
  by another actor and by the claimant ahead of the free work, then
  claims with and without an assignee filter. The unassigned-only claim
  is now pinned over a real served server, not only through the fakes:
  red with the pre-fixup remote_roles.go, with filter.Unassigned
  dropped, and (the filtered claim) with an explicit assignee honored.
- The capabilities description in openapi.v0.yaml (and the regenerated
  types.gen.go comment) no longer calls the whole list build-level:
  policy.external_dependencies depends on how the server composed its
  roles, as the paragraph above it says.
- createbatchequiv's golden note names
  issueops.PreparePublicCreateRequest instead of a commit id that is
  not on this branch.

Agent-Signature: claude-code-claude-opus-5-5-max on behalf of Julian Knutsen
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* test(backend/http): count a not_found read as reaching the remote in #7469's credential doors

main's #7469 added TestExplicitCredentialIgnoresTheEnvPlaintextGrant. Its
OpenWith and Open doors read bd-1 from plaintextRemote, which answers
every issue read not_found, and the granted leg needs that read to return
a nil error. That held while the http client answered a miss with
(nil, nil). This branch's "fix(httpclient): GetIssue answers a miss with
storage.ErrNotFound, like the local stores" makes the same read return
storage.ErrNotFound. So on main plus this branch both doors fail at
per_open_credential_test.go:392 ("with Target.AllowInsecureCredential:
not found: issue bd-1") under plain go test. The merge is textually
clean, so only a build of the merge shows it.

The two store doors now count storage.ErrNotFound as success, since that
answer came off the wire. The assertions are unchanged. The refused leg
still needs the "refusing to send a credential" error and no request on
the transport. The granted leg still needs exactly one request carrying
"Bearer explicit-token": a granted read that never reaches the wire still
fails at :408.

Agent-Signature: claude-code-claude-opus-5-5-max on behalf of Julian Knutsen
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-10 18:11:56 +00:00

304 lines
14 KiB
Go

// Contributed by gascity from bd-enterprise (internal/enterprise/httpstore/batchcreator.go@49d1df2f6)
// to OSS beads under the MIT license.
package httpclient
import (
"context"
"fmt"
"reflect"
"github.com/steveyegge/beads/internal/httpapi/apigen"
"github.com/steveyegge/beads/internal/httpclient/encode"
"github.com/steveyegge/beads/issueops"
)
// maxBatchCreateItems mirrors the wire's own bound (internal/httpapi's
// batch_create.go, and the document's maxItems). It is checked here for
// maxDeleteIDs' reason: the request IS the transaction, so splitting a longer
// plan into two requests would turn one atomic create into two — and half a
// file is the outcome the role's all-or-nothing promise exists to make
// impossible. A caller that really has more than a hundred issues splits the
// plan deliberately, which is the document's own advice.
const maxBatchCreateItems = 100
// batchCreateCarriedIssueMembers is the wire's item vocabulary: the eight
// members of apigen.BatchCreateItem that describe the issue itself, keyed by the
// types.Issue field each one carries.
//
// It is the ALLOWLIST half of refuse-not-drop for this operation. What it does
// not name is refused, and there is no third arm — see refuseUnwirableIssue.
//
// Status and CreatedBy are deliberately absent, each for its own reason, and
// neither belongs in roleIgnoredCreateIssueMembers below: both are genuinely
// ACCEPTED by the role's canonical create rules (CreateRequest.Issue's doc,
// which BatchCreateItem.Issue inherits without exception), so silently
// dropping either would be exactly the data loss refuse-not-drop exists to
// prevent.
// - Status: apigen.BatchCreateItem publishes no status member at all, unlike
// single create's apigen.CreateIssueRequest (which does, see
// createCarriedIssueMembers). A populated value is correctly refused. The
// common case is not lost: PreparePublicCreateRequest defaults an empty
// Status to StatusOpen on every backend, so a caller that only ever wants
// the default (cmd/bd/markdown.go's `bd create --file`) leaves it unset
// rather than spelling out "open" and tripping this refusal. That removes
// ONE refusal from `bd create --file`, not all of them: its request still
// always names a Provenance (W-CreateBatchRequest.Provenance) and usually
// an Owner from git config (W-BatchCreateItem.Issue), so it still refuses
// over this wire.
// - CreatedBy: apigen.BatchCreateItem has no member for it either, but the
// server's create role defaults every item's created_by to the request's
// actor (issueops.PreparePublicCreateRequest), as single create does. A CreatedBy
// naming the actor is therefore carried BY the actor
// (actorStampedCreateMember below), and any other value is refused rather
// than silently replaced by the stamp.
var batchCreateCarriedIssueMembers = map[string]string{
"Title": "title",
"Description": "description",
"Design": "design",
"AcceptanceCriteria": "acceptance_criteria",
"Priority": "priority",
"IssueType": "issue_type",
"Assignee": "assignee",
"Labels": "labels",
}
// roleIgnoredCreateIssueMembers are the members the ROLE ITSELF ignores on a
// create, each with the reason, taken from issueops.CreateRequest.Issue's own
// list: "It ignores ContentHash, RowVersion, lease state, compaction state,
// routing overrides, hydration flags, and derived fields."
//
// They are not divergences and must not be refused. A local create drops them
// too, so refusing here would make an http workspace REJECT a request every
// other backend accepts — the opposite failure from the one refuse-not-drop
// guards, and just as wrong.
var roleIgnoredCreateIssueMembers = map[string]string{
"ContentHash": "derived: recomputed from the stored content",
"RowVersion": "derived: the engine stamps its own row lock",
"LeaseExpiresAt": "lease state: a create grants no lease",
"HeartbeatAt": "lease state: a create grants no lease",
"LeaseGrantedNode": "lease state: a create grants no lease",
"CompactionLevel": "compaction state: nothing is compacted at create",
"CompactedAt": "compaction state: nothing is compacted at create",
"CompactedAtCommit": "compaction state: nothing is compacted at create",
"OriginalSize": "compaction state: nothing is compacted at create",
"SourceRepo": "routing override: which local database owns the row",
"IDPrefix": "routing override: id generation is the server's",
"PrefixOverride": "routing override: id generation is the server's",
"WispPlaneOverride": "routing override: import's explicit plane marker",
"IsLitePartial": "hydration flag: describes a READ, not a create",
}
// actorStampedCreateMember reports whether a populated issue member is one the
// server writes from the request's actor rather than reads from the body, and
// already holds the value that stamp will write.
//
// CreatedBy is the one such member: every create shape's role defaults an empty
// created_by to the actor (issueops.PreparePublicCreateRequest), on the server
// as locally. It is neither carried nor role-ignored — a local create keeps
// whatever explicit value the issue names — so it is carried BY THE ACTOR: a CreatedBy that names the actor,
// which is what `bd create`, `bd create --file` and the graph apply send,
// arrives as written, and any other value would be silently replaced by the
// stamp and is refused.
func actorStampedCreateMember(member string, issue *issueops.Issue, actor string) bool {
return member == "CreatedBy" && issue.CreatedBy == actor
}
// httpBatchCreator serves issueops.BatchCreator from the batchCreateIssues
// custom method (design D8 row 14) — the write side of `bd create --file`.
//
// THE REQUEST IS THE TRANSACTION on both sides, and that is the whole reason
// this composes at all: the wire's operation is itself all-or-nothing, so one
// role call is one request is one server-side transaction with at most one
// history entry. Nothing here loops, and nothing here chunks.
//
// WHAT THE WIRE'S ITEM CANNOT SAY is where the work is. apigen.BatchCreateItem
// publishes eight content members and a dependency list; issueops reads a whole
// types.Issue, and the role accepts far more of it than that — an explicit id,
// the wisp flags, metadata, the gate and molecule fields, every timestamp.
// Every one of those is refused rather than dropped (ledger row
// W-BatchCreateItem.Issue): a create that reported success having silently
// planted an issue in the durable tier that the caller asked to be ephemeral is
// data loss the caller has no way to learn about.
//
// The refusal is decided by REFLECTION over the two tables above rather than by
// a hand-written switch, so a member added to types.Issue tomorrow is refused
// the day it lands instead of dropped until someone notices.
type httpBatchCreator struct {
store *Store
wire WriteWire
}
var _ issueops.BatchCreator = (*httpBatchCreator)(nil)
// CreateBatch dials POST /v0/beads/issues:batchCreate.
func (b *httpBatchCreator) CreateBatch(ctx context.Context, req issueops.CreateBatchRequest) (result issueops.CreateBatchResult, err error) {
// Write-side parity with reads: decorates a bare *encode.RefusedError —
// however deeply batchCreateItem/batchCreateEdge/refuseUnwirableIssue
// nested it inside an "items[%d]..." prefix — into *InexpressibleError so
// errors.As(err, &unsupported) reaches *storage.ErrUnsupported, same as
// inexpressible does for a read role. The original composite message
// (including that prefix) is preserved in the decorated error's own text.
defer func() { err = b.store.inexpressible("BatchCreator.CreateBatch", err) }()
if err := requireActor(req.Actor); err != nil {
return issueops.CreateBatchResult{}, err
}
if len(req.Items) == 0 {
return issueops.CreateBatchResult{}, invalid("a batch create names no items")
}
if len(req.Items) > maxBatchCreateItems {
return issueops.CreateBatchResult{}, refuse(encode.OpBatchCreateIssues, "L-batchcreate-bound")
}
if req.Provenance != "" {
return issueops.CreateBatchResult{}, refuse(encode.OpBatchCreateIssues, "W-CreateBatchRequest.Provenance")
}
if req.ForceIDPrefix {
return issueops.CreateBatchResult{}, refuse(encode.OpBatchCreateIssues, "W-CreateBatchRequest.ForceIDPrefix")
}
items := make([]apigen.BatchCreateItem, 0, len(req.Items))
for i, item := range req.Items {
wireItem, err := batchCreateItem(i, item, req.Actor)
if err != nil {
return issueops.CreateBatchResult{}, err
}
items = append(items, wireItem)
}
priorities := make([]**int, len(items))
for i := range items {
priorities[i] = &items[i].Priority
}
if err := b.store.pinCreateDefaultPriority(ctx, priorities...); err != nil {
return issueops.CreateBatchResult{}, err
}
res, err := b.wire.BatchCreateIssues(ctx, apigen.BatchCreateRequest{Actor: req.Actor, Items: items})
if err != nil {
return issueops.CreateBatchResult{}, err
}
// One entry per requested item, in request order, never nil. The response is
// read back rather than the request echoed because the GENERATED IDS are the
// one fact the request cannot carry — and a server that answered a different
// length would be caught here rather than by an index panic upstream.
if len(res.Items) != len(req.Items) {
return issueops.CreateBatchResult{}, fmt.Errorf(
"batchCreateIssues answered %d issues for %d items; the operation is all-or-nothing and has no partial outcome",
len(res.Items), len(req.Items))
}
issues := make([]*issueops.Issue, len(res.Items))
for i := range res.Items {
issue := res.Items[i]
issues[i] = &issue
}
return issueops.CreateBatchResult{Issues: issues}, nil
}
// batchCreateItem projects one role item onto the wire's item.
func batchCreateItem(index int, item issueops.BatchCreateItem, actor string) (apigen.BatchCreateItem, error) {
if item.Issue == nil {
return apigen.BatchCreateItem{}, invalid("items[%d] carries no issue", index)
}
if len(item.Issue.Comments) > 0 || len(item.Issue.Dependencies) > 0 {
// The ROLE's own rule, not a wire divergence: edges are supplied through
// the item's own Dependencies, and a create batch has no way to supply
// comments at all. A local backend refuses this too.
return apigen.BatchCreateItem{}, invalid(
"items[%d].Issue carries comments or dependencies; supply edges through the item's own Dependencies", index)
}
if err := refuseUnwirableIssue(index, item.Issue, actor); err != nil {
return apigen.BatchCreateItem{}, err
}
// Priority is sent whenever the item names one, unlike the five optional
// strings (see wirePriority).
priority, err := wirePriority(item.Issue.Priority, item.DefaultPriority)
if err != nil {
return apigen.BatchCreateItem{}, err
}
wireItem := apigen.BatchCreateItem{Title: item.Issue.Title, Priority: priority}
setItemString(&wireItem.Description, item.Issue.Description)
setItemString(&wireItem.Design, item.Issue.Design)
setItemString(&wireItem.AcceptanceCriteria, item.Issue.AcceptanceCriteria)
setItemString(&wireItem.Assignee, item.Issue.Assignee)
setItemString(&wireItem.IssueType, string(item.Issue.IssueType))
if len(item.Issue.Labels) > 0 {
labels := append([]string(nil), item.Issue.Labels...)
wireItem.Labels = &labels
}
if len(item.Dependencies) > 0 {
edges := make([]apigen.BatchCreateDependency, 0, len(item.Dependencies))
for j, dep := range item.Dependencies {
edge, err := batchCreateEdge(index, j, dep)
if err != nil {
return apigen.BatchCreateItem{}, err
}
edges = append(edges, edge)
}
wireItem.Dependencies = &edges
}
return wireItem, nil
}
// batchCreateEdge projects one requested edge. The wire's edge carries a target
// and a type and nothing else, so the three members issueops.CreateDependency
// adds refuse.
func batchCreateEdge(index, j int, dep issueops.CreateDependency) (apigen.BatchCreateDependency, error) {
where := func(err error) error { return fmt.Errorf("items[%d].dependencies[%d]: %w", index, j, err) }
switch {
case dep.TargetID == "":
return apigen.BatchCreateDependency{}, where(invalid("target_id is required"))
case dep.Type == "":
return apigen.BatchCreateDependency{}, where(invalid("type is required"))
case dep.Reverse:
return apigen.BatchCreateDependency{}, where(refuse(encode.OpBatchCreateIssues, "W-CreateDependency.Reverse"))
case dep.Metadata != "":
return apigen.BatchCreateDependency{}, where(refuse(encode.OpBatchCreateIssues, "W-CreateDependency.Metadata"))
case dep.ThreadID != "":
return apigen.BatchCreateDependency{}, where(refuse(encode.OpBatchCreateIssues, "W-CreateDependency.ThreadID"))
}
return apigen.BatchCreateDependency{TargetId: dep.TargetID, Type: string(dep.Type)}, nil
}
// refuseUnwirableIssue is the other half of the allowlist: every populated
// member of the issue that is neither carried by the wire, nor ignored by the
// role, nor stamped from the actor (actorStampedCreateMember).
//
// It answers the FIRST offender in declaration order, which is deterministic —
// a caller fixing one member at a time must not see the reported member depend
// on map iteration.
func refuseUnwirableIssue(index int, issue *issueops.Issue, actor string) error {
value := reflect.ValueOf(*issue)
shape := value.Type()
for i := range shape.NumField() {
field := shape.Field(i)
if !field.IsExported() {
continue
}
if _, carried := batchCreateCarriedIssueMembers[field.Name]; carried {
continue
}
if _, ignored := roleIgnoredCreateIssueMembers[field.Name]; ignored {
continue
}
if value.Field(i).IsZero() || actorStampedCreateMember(field.Name, issue, actor) {
continue
}
// The ledger row is the vocabulary; the member name is the fact the row
// cannot carry, because one row covers the whole population.
return fmt.Errorf("items[%d].Issue.%s: %w",
index, field.Name, refuse(encode.OpBatchCreateIssues, "W-BatchCreateItem.Issue"))
}
return nil
}
// setItemString writes an optional wire member, leaving it absent when the role
// carried nothing. An empty string and an omitted member mean the same thing on
// every one of these five, so absent is the honest encoding.
func setItemString(dest **string, value string) {
if value == "" {
return
}
v := value
*dest = &v
}