* fix(issueops): enforce the template read-only update guard on every leg
The refusal of an update to a template (validateIssueUpdatable) lived only
in cmd/bd as a pre-read, so PATCH /v0/beads/issues/{id}, batch:apply update
items and library callers of Lifecycle.Update / BatchApplier edited
templates that `bd update` refused.
It is now one role rule, storage issueops.AuthorizeTemplateUpdate, returning
*issueops.TemplateReadOnlyError (matches ErrTemplateReadOnly; the message is
the sentence bd always printed). It runs in the update's own transaction,
after the compare-and-set preconditions (a stale guard still reports the
mismatch), and no force flag waives it:
- ExecuteUpdate (dolt, embedded) and the uow Update and batch update legs;
- the batch apply metadata splice that finishes a create item stays
unguarded on both bodies (a template the request creates is not modified);
- httpapi maps it to 409 template_read_only on updateIssue and applyBatch
(spec x-bd-codes and descriptions updated, apigen regenerated) and the
client rebuilds the typed error.
UpdateRequest.AllowTemplate stands the guard down for one request: the
caller edits a template deliberately. bd label (add, remove, remove-prefix)
and bd set-state set it, so they keep editing templates on every route, as
on origin/main. Over HTTP it is the optional `allow_template` member of the
PATCH body, advertised by the issues.update.allowTemplate behavior token,
which also says the server enforces the guard. httpclient Lifecycle.Update
decides from the cached handshake before the dial: against a server without
the token (no guard, no member) it runs the same rule
(AuthorizeTemplateUpdate) on a pre-read and never sends allow_template, so a
new bd against an older bd serve still refuses template updates.
cmd/bd: bd update, bd assign and the proxied assign/tag drop their pre-read
and print the role's refusal with the same line and exit code.
Conformance: RunLifecycleUpdateRefusesATemplate,
RunLifecycleUpdateAllowTemplateEditsATemplate,
RunBatchApplyUpdateItemsRefuseATemplate and
RunBatchApplySplicesTheMetadataOfATemplateItCreates on dolt, embedded, uow
and http (the http splice case is parked: the v0 create item has no
is_template member), plus handler and CLI rendering tests, and
TestUpdateTemplateGuardAgainstAServerThatPredatesIt (new client, handshake
without the token: refused before the dial, allow_template not sent).
Skew note (CHANGELOG): an older bd label / bd set-state against a new server
cannot send allow_template and now gets 409 template_read_only on a template.
bd comment, note, priority and tag keep their CLI-only pre-read guard.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* fix(issueops): scope template read-only docs to updates, test label stand-down
Review fixups for PR 7427 (adopt-pr review loop, iteration 1):
- Contract: the role guard covers updates, not every mutation. The
CHANGELOG headline, ErrTemplateReadOnly and CodeTemplateReadOnly now
say so, and "Not yet moved" names claim, reopen, :casMetadata and the
served addComment, which have no template check yet (a PATCH with
claim: true refuses a template that POST :claim still claims). Close
is #7425's. Follow-up: bd-jkp9v3.
- Skew: the CapIssuesUpdateAllowTemplate client fallback covers
updateIssue only. A batch update item gets no client-side check, so
through an older bd serve it still edits a template; the CHANGELOG
and both capability docs say so.
- Tests: a template row now goes through the CLI on both tiers
(TestEmbeddedLabelEditReports, TestProxiedServerLabelC). bd label add,
bd label remove --prefix and bd set-state edit it (AllowTemplate);
bd update --title and bd assign exit 1 with the template sentence and
leave it unchanged. Mutants: dropping AllowTemplate from label.go and
state.go reds the three edits on both tiers; disabling
AuthorizeTemplateUpdate reds update and assign on both tiers.
- Stale comments: runTagProxiedServer, applyUpdateProxiedOne,
proxiedUpdateTarget, UpdateFlags (five booleans, not four) and the
ItemUpdate notes in applyLabelEdit and bd label propagate's proxied
route (UpdateItem has no AllowTemplate).
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>
708 lines
30 KiB
Go
708 lines
30 KiB
Go
package httpapi
|
|
|
|
import (
|
|
"bytes"
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"net/http"
|
|
"strings"
|
|
"time"
|
|
"unicode/utf8"
|
|
|
|
"github.com/steveyegge/beads/internal/httpapi/apigen"
|
|
"github.com/steveyegge/beads/internal/storage"
|
|
"github.com/steveyegge/beads/internal/types"
|
|
"github.com/steveyegge/beads/issueops"
|
|
)
|
|
|
|
const (
|
|
// updatePatchMember is the member carrying the fields to write. Nesting them
|
|
// rather than spreading them beside `actor` keeps the patch vocabulary a
|
|
// closed set that can grow without ever colliding with a request-level
|
|
// member.
|
|
updatePatchMember = "patch"
|
|
// updateClaimMember asks the update to CLAIM the issue for `actor` in the
|
|
// same transaction as the patch: issueops.UpdateRequest.Claim, which is
|
|
// what `bd update --claim` sends on the direct route.
|
|
updateClaimMember = "claim"
|
|
// maxUpdateBodyBytes bounds the request body. A patch can carry a
|
|
// description, a design and acceptance criteria at once, so the claim's
|
|
// megabyte is too tight and the batch's four is the right order.
|
|
maxUpdateBodyBytes = 4 << 20
|
|
)
|
|
|
|
// updateRequestMembers and issuePatchMembers are the document's member lists at
|
|
// each level, refused BY NAME for the reason every other body on this surface
|
|
// is: encoding/json's DisallowUnknownFields reports the offender only inside an
|
|
// error string.
|
|
var (
|
|
updateRequestMembers = []string{
|
|
"actor", updateClaimMember, "expected_assignee", "expected_status", "expected_version",
|
|
"force_assignee_transfer", "force_close_policy", "force_notes_overwrite", "allow_template",
|
|
updatePatchMember,
|
|
}
|
|
issuePatchMembers = []string{
|
|
"title", "description", "design", "acceptance_criteria",
|
|
"notes", "append_notes", "priority", "issue_type", "status",
|
|
"assignee", "parent_id", "labels", "add_labels", "remove_labels", "metadata",
|
|
"estimated_minutes", "external_ref", "due_at", "defer_until",
|
|
}
|
|
// nullablePatchMembers is the closed set on which explicit `null` CLEARS
|
|
// rather than refuses. They are exactly the members the role models as
|
|
// Field[*T], because a pointer is the only thing a clear has to write.
|
|
nullablePatchMembers = map[string]bool{
|
|
"estimated_minutes": true,
|
|
"external_ref": true,
|
|
"due_at": true,
|
|
"defer_until": true,
|
|
}
|
|
)
|
|
|
|
// handleUpdate edits the fields of one issue.
|
|
//
|
|
// It carries the claim's posture verbatim. The actor is caller-ASSERTED
|
|
// provenance for the audit trail and not authenticated identity; hooks do not
|
|
// fire and the per-command auto-commit machinery does not run, exactly as for
|
|
// POST /v0/beads/issues/{id}:claim. The only durable effect is the single
|
|
// storage commit the role makes inside its own transaction.
|
|
//
|
|
// A PLAIN PATCH on the issue-detail path rather than a custom method, so the id
|
|
// arrives from the router's own wildcard and there is no suffix to split. The
|
|
// id bound is this handler's, because it is not on the dispatcher's pattern.
|
|
//
|
|
// PLANES, as for close and reopen: the id resolves across both.
|
|
func (s *Server) handleUpdate(w http.ResponseWriter, r *http.Request) {
|
|
id, ok := s.updateTarget(w, r)
|
|
if !ok {
|
|
return
|
|
}
|
|
if !s.requireNoQuery(w, r) {
|
|
return
|
|
}
|
|
if !s.requireJSONContent(w, r) {
|
|
return
|
|
}
|
|
request, ok := s.updateRequest(w, r, id)
|
|
if !ok {
|
|
return
|
|
}
|
|
|
|
lifecycle, err := s.lifecycle(r)
|
|
if err != nil {
|
|
s.failUpdate(w, r, request, err)
|
|
return
|
|
}
|
|
result, err := lifecycle.Update(r.Context(), request)
|
|
if err != nil {
|
|
s.failUpdate(w, r, request, err)
|
|
return
|
|
}
|
|
// `changed` is the role's own verbatim: a same-value patch is a 200 with
|
|
// false, not an error — idempotent, like every replay answer here.
|
|
//
|
|
// `revision` is the row's post-write concurrency token, read off the same
|
|
// snapshot rather than computed. It is on the wire because `expected_version`
|
|
// is: a guard whose token no response carries is a guard a caller cannot
|
|
// fill. types.Issue.RowVersion is `json:"-"`, so the Issue body cannot carry
|
|
// it and this member is where it lives.
|
|
writeJSON(w, apigen.UpdateIssueResponse{
|
|
Issue: *result.Issue,
|
|
Changed: result.Changed,
|
|
Revision: types.RevisionToken(result.Issue.RowVersion),
|
|
})
|
|
}
|
|
|
|
// updateTarget reads and bounds the id this operation addresses.
|
|
//
|
|
// The bound is the dispatcher's, applied here because this route is not on the
|
|
// dispatcher's pattern: an id longer than the column, or carrying a control
|
|
// character a percent-escape decoded to, names no row that can exist, and it
|
|
// gets the SAME 404 a real miss gets so a caller cannot map the server's notion
|
|
// of a well-formed id.
|
|
func (s *Server) updateTarget(w http.ResponseWriter, r *http.Request) (string, bool) {
|
|
id := r.PathValue("id")
|
|
if id == "" || types.CheckFieldLen("id", id) != nil || strings.ContainsFunc(id, isControlChar) {
|
|
s.fail(w, r, NotFound())
|
|
return "", false
|
|
}
|
|
return id, true
|
|
}
|
|
|
|
// updateRequest decodes and validates the body, and reports whether the request
|
|
// may proceed. Every refusal here happens BEFORE any database work.
|
|
func (s *Server) updateRequest(w http.ResponseWriter, r *http.Request, id string) (issueops.UpdateRequest, bool) {
|
|
members, res := decodeJSONObject(w, r, maxUpdateBodyBytes)
|
|
if res != nil {
|
|
s.fail(w, r, *res)
|
|
return issueops.UpdateRequest{}, false
|
|
}
|
|
if offender, unknown := unknownMember(members, updateRequestMembers); unknown {
|
|
s.failUnknownMember(w, r, offender, updateRequestMembers)
|
|
return issueops.UpdateRequest{}, false
|
|
}
|
|
|
|
actor, ok := s.bodyActor(w, r, members)
|
|
if !ok {
|
|
return issueops.UpdateRequest{}, false
|
|
}
|
|
// Read BEFORE the patch, because it decides whether an empty patch is a
|
|
// request: a claim that edits nothing else is `bd update <id> --claim`.
|
|
claim, ok := s.booleanMember(w, r, members, updateClaimMember)
|
|
if !ok {
|
|
return issueops.UpdateRequest{}, false
|
|
}
|
|
patch, ok := s.issuePatch(w, r, id, members, claim)
|
|
if !ok {
|
|
return issueops.UpdateRequest{}, false
|
|
}
|
|
|
|
expectedVersion, res := applyVersionGuardMember(members, "")
|
|
if res != nil {
|
|
s.fail(w, r, *res)
|
|
return issueops.UpdateRequest{}, false
|
|
}
|
|
expectedStatus, ok := s.updateExpectedStatus(w, r, members)
|
|
if !ok {
|
|
return issueops.UpdateRequest{}, false
|
|
}
|
|
expectedAssignee, ok := s.updateExpectedAssignee(w, r, members)
|
|
if !ok {
|
|
return issueops.UpdateRequest{}, false
|
|
}
|
|
forceClosePolicy, ok := s.booleanMember(w, r, members, "force_close_policy")
|
|
if !ok {
|
|
return issueops.UpdateRequest{}, false
|
|
}
|
|
forceAssigneeTransfer, ok := s.booleanMember(w, r, members, "force_assignee_transfer")
|
|
if !ok {
|
|
return issueops.UpdateRequest{}, false
|
|
}
|
|
forceNotesOverwrite, ok := s.booleanMember(w, r, members, "force_notes_overwrite")
|
|
if !ok {
|
|
return issueops.UpdateRequest{}, false
|
|
}
|
|
// allow_template is passed through: the role owns the template guard and
|
|
// what standing it down means.
|
|
allowTemplate, ok := s.booleanMember(w, r, members, "allow_template")
|
|
if !ok {
|
|
return issueops.UpdateRequest{}, false
|
|
}
|
|
if forceNotesOverwrite && !patch.Notes.Set {
|
|
s.fail(w, r, InvalidArgument("force_notes_overwrite", ReasonInvalidValue,
|
|
"`force_notes_overwrite` bypasses the fence on a NOTES REPLACEMENT; send `patch.notes` with it"))
|
|
return issueops.UpdateRequest{}, false
|
|
}
|
|
// The role refuses a claim beside the assignee and status guards, and a
|
|
// claim beside the forced transfer (ValidateUpdateRequest): the claim is
|
|
// its own compare-and-set, with claim-pool eligibility the guards do not
|
|
// know. Refused HERE, naming `claim`, for the reason the pair below is — a
|
|
// role ErrValidation would otherwise reach the client as the generic
|
|
// "a patch value was refused" 400, naming a member the caller never got
|
|
// wrong. `expected_version` is NOT refused: the role checks it before the
|
|
// claim, exactly as on the direct route.
|
|
if claim {
|
|
for _, conflicting := range []struct {
|
|
present bool
|
|
member string
|
|
}{
|
|
{expectedAssignee != nil, "expected_assignee"},
|
|
{expectedStatus != nil, "expected_status"},
|
|
{forceAssigneeTransfer, "force_assignee_transfer"},
|
|
} {
|
|
if conflicting.present {
|
|
s.fail(w, r, InvalidArgument(updateClaimMember, ReasonInvalidValue,
|
|
"`claim` is its own compare-and-set; it cannot be combined with `"+conflicting.member+"`"))
|
|
return issueops.UpdateRequest{}, false
|
|
}
|
|
}
|
|
}
|
|
// The role documents both combinations as invalid, and refusing them HERE
|
|
// keeps the 400 a statement about the request rather than a translated
|
|
// storage error — the `notes`/`append_notes` rule, applied to the two
|
|
// members that would otherwise reach a role obliged to guess which of the
|
|
// caller's two opinions about the assignee wins.
|
|
if forceAssigneeTransfer {
|
|
switch {
|
|
case expectedAssignee != nil:
|
|
s.fail(w, r, InvalidArgument("force_assignee_transfer", ReasonInvalidValue,
|
|
"`expected_assignee` is the compare-and-set that replaces the fence; `force_assignee_transfer` bypasses it. Send one"))
|
|
return issueops.UpdateRequest{}, false
|
|
case !patch.Assignee.Set:
|
|
s.fail(w, r, InvalidArgument("force_assignee_transfer", ReasonInvalidValue,
|
|
"`force_assignee_transfer` bypasses the fence on an assignee TRANSFER; send `patch.assignee` with it"))
|
|
return issueops.UpdateRequest{}, false
|
|
}
|
|
}
|
|
|
|
// Claim is passed through, not re-implemented: the lifecycle role applies
|
|
// the same claim `bd update --claim` gets on the direct route — eligibility,
|
|
// claim pools, same-actor idempotence — in the transaction that applies the
|
|
// patch, so a refused claim writes none of it. IssuePlaneOnly stays ZERO,
|
|
// because this operation resolves across both planes.
|
|
return issueops.UpdateRequest{
|
|
Actor: actor,
|
|
IssueID: id,
|
|
Patch: patch,
|
|
Claim: claim,
|
|
ExpectedVersion: expectedVersion,
|
|
ExpectedStatus: expectedStatus,
|
|
ExpectedAssignee: expectedAssignee,
|
|
ForceClosePolicy: forceClosePolicy,
|
|
ForceAssigneeTransfer: forceAssigneeTransfer,
|
|
ForceNotesOverwrite: forceNotesOverwrite,
|
|
AllowTemplate: allowTemplate,
|
|
Provenance: updateProvenance,
|
|
}, true
|
|
}
|
|
|
|
// updateExpectedStatus reads the status precondition, preserving the difference
|
|
// between an absent guard and one that expects the empty status. The role
|
|
// models it as a POINTER for exactly that reason, so an absent member must not
|
|
// collapse into a guard on "".
|
|
func (s *Server) updateExpectedStatus(w http.ResponseWriter, r *http.Request, members map[string]json.RawMessage) (*issueops.Status, bool) {
|
|
if _, present := members["expected_status"]; !present {
|
|
return nil, true
|
|
}
|
|
value, ok := s.storedTextMember(w, r, members, "expected_status")
|
|
if !ok {
|
|
return nil, false
|
|
}
|
|
status := issueops.Status(value)
|
|
return &status, true
|
|
}
|
|
|
|
// updateExpectedAssignee is updateExpectedStatus's twin, and the difference
|
|
// between nil and a pointer to "" is load-bearing here too: a guard on the
|
|
// EMPTY assignee is how a caller says "only if nobody holds it".
|
|
func (s *Server) updateExpectedAssignee(w http.ResponseWriter, r *http.Request, members map[string]json.RawMessage) (*string, bool) {
|
|
if _, present := members["expected_assignee"]; !present {
|
|
return nil, true
|
|
}
|
|
value, ok := s.storedTextMember(w, r, members, "expected_assignee")
|
|
if !ok {
|
|
return nil, false
|
|
}
|
|
return &value, true
|
|
}
|
|
|
|
// updateProvenance labels the history entry an update records, naming this
|
|
// surface for reopenProvenance's reason: the role's implementations disagree
|
|
// about their own default, so a spelled label is what makes an entry read the
|
|
// same whichever backend answered. Not wire-visible.
|
|
const updateProvenance = "bd serve: update issue"
|
|
|
|
// issuePatch projects the decoded `patch` member onto the role's IssuePatch.
|
|
//
|
|
// MEMBER PRESENCE IS THE SIGNAL, which is the whole reason the body is decoded
|
|
// as raw members: a member present sets the role's Field, a member absent
|
|
// leaves the field untouched, and the generated struct cannot tell those apart
|
|
// because it models both as a nil pointer. Explicit `null` is a third state
|
|
// this reads directly off the raw bytes — a clear on the four nullable members,
|
|
// and a 400 naming the member everywhere else.
|
|
//
|
|
// An EMPTY patch is a request only beside `claim`: the claim is then the whole
|
|
// write, which is `bd update <id> --claim` with no other flag.
|
|
func (s *Server) issuePatch(w http.ResponseWriter, r *http.Request, id string, members map[string]json.RawMessage, claim bool) (issueops.IssuePatch, bool) {
|
|
refuse := func(member, detail string) (issueops.IssuePatch, bool) {
|
|
s.fail(w, r, InvalidArgument(patchParam(member), ReasonInvalidValue, detail))
|
|
return issueops.IssuePatch{}, false
|
|
}
|
|
|
|
raw, ok := members[updatePatchMember]
|
|
if !ok {
|
|
return refuse("", "`"+updatePatchMember+"` is required")
|
|
}
|
|
var fields map[string]json.RawMessage
|
|
if err := json.Unmarshal(raw, &fields); err != nil || fields == nil {
|
|
return refuse("", "`"+updatePatchMember+"` must be a JSON object")
|
|
}
|
|
if len(fields) == 0 {
|
|
if claim {
|
|
return issueops.IssuePatch{}, true
|
|
}
|
|
// A write that writes nothing is a client bug, not a no-op to answer —
|
|
// the batch-create empty-items judgement, applied to a patch.
|
|
return refuse("", "`"+updatePatchMember+"` must carry at least one field, or ride beside `"+updateClaimMember+"`; an update that updates nothing is refused rather than answered")
|
|
}
|
|
if offender, unknown := unknownMember(fields, issuePatchMembers); unknown {
|
|
s.failUnknownMember(w, r, patchParam(offender), issuePatchMembers)
|
|
return issueops.IssuePatch{}, false
|
|
}
|
|
|
|
// Explicit null, before any typed decode: unmarshaling null into *T yields
|
|
// nil, which is indistinguishable from the member being absent, so a null on
|
|
// a non-nullable member would otherwise slide through as "untouched" — a
|
|
// write the client asked for and the server silently dropped.
|
|
for name, value := range fields {
|
|
if isJSONNull(value) && !nullablePatchMembers[name] {
|
|
return refuse(name, "`"+name+"` is not nullable; omit it to leave the field unchanged")
|
|
}
|
|
}
|
|
|
|
// The typed decode, which is what makes a member's type the DOCUMENT's
|
|
// type: `priority: "high"` is refused here rather than reaching a role that
|
|
// would have to guess what the caller meant.
|
|
var wire apigen.IssuePatchBody
|
|
if err := json.Unmarshal(raw, &wire); err != nil {
|
|
return refuse("", "a `"+updatePatchMember+"` member carries the wrong JSON type")
|
|
}
|
|
|
|
patch := issueops.IssuePatch{}
|
|
set := func(name string) bool { _, present := fields[name]; return present }
|
|
|
|
if set("title") {
|
|
title := *wire.Title
|
|
if strings.TrimSpace(title) == "" {
|
|
return refuse("title", "`title` must not be blank")
|
|
}
|
|
if types.CheckFieldLen("title", title) != nil {
|
|
return refuse("title", fmt.Sprintf("`title` is %d characters; storage holds at most %d",
|
|
utf8.RuneCountInString(title), types.MaxFieldLen))
|
|
}
|
|
patch.Title = issueops.Field[string]{Set: true, Value: title}
|
|
}
|
|
if set("description") {
|
|
patch.Description = issueops.Field[string]{Set: true, Value: *wire.Description}
|
|
}
|
|
if set("design") {
|
|
patch.Design = issueops.Field[string]{Set: true, Value: *wire.Design}
|
|
}
|
|
if set("acceptance_criteria") {
|
|
patch.AcceptanceCriteria = issueops.Field[string]{Set: true, Value: *wire.AcceptanceCriteria}
|
|
}
|
|
// The role refuses both together too, but refusing here keeps the 400 a
|
|
// statement about the request rather than a translated storage error.
|
|
if set("notes") && set("append_notes") {
|
|
return refuse("append_notes", "`notes` replaces the notes and `append_notes` adds to them; send one")
|
|
}
|
|
if set("notes") {
|
|
patch.Notes = issueops.Field[string]{Set: true, Value: *wire.Notes}
|
|
}
|
|
if set("append_notes") {
|
|
patch.AppendNotes = issueops.Field[string]{Set: true, Value: *wire.AppendNotes}
|
|
}
|
|
if set("priority") {
|
|
priority := *wire.Priority
|
|
if priority < 0 || priority > 4 {
|
|
return refuse("priority", fmt.Sprintf("`priority` is %d; the range is 0 to 4", priority))
|
|
}
|
|
patch.Priority = issueops.Field[int]{Set: true, Value: priority}
|
|
}
|
|
// Only what the SCHEMA declares is checked for these four. Whether a value is
|
|
// in this workspace's configured vocabulary is the ROLE's question and cannot
|
|
// be asked without a transaction; failUpdate answers that one. A SLICE and
|
|
// not a map, so a patch breaking two rules always names the same offender.
|
|
for _, bounded := range []struct {
|
|
member string
|
|
value *string
|
|
}{
|
|
{"issue_type", wire.IssueType}, {"status", wire.Status},
|
|
{"assignee", wire.Assignee}, {"parent_id", wire.ParentId},
|
|
} {
|
|
if res := applyBoundedText(updatePatchMember+".", bounded.member, bounded.value); res != nil {
|
|
s.fail(w, r, *res)
|
|
return issueops.IssuePatch{}, false
|
|
}
|
|
}
|
|
if set("issue_type") {
|
|
patch.IssueType = issueops.Field[issueops.IssueType]{Set: true, Value: issueops.IssueType(*wire.IssueType)}
|
|
}
|
|
if set("status") {
|
|
patch.Status = issueops.Field[issueops.Status]{Set: true, Value: issueops.Status(*wire.Status)}
|
|
}
|
|
if set("assignee") {
|
|
patch.Assignee = issueops.Field[string]{Set: true, Value: *wire.Assignee}
|
|
}
|
|
if set("parent_id") {
|
|
// A self-parent is refused HERE, and it is the one graph rule this
|
|
// handler can apply: the child is the id in the PATH, so the request
|
|
// contradicts itself without any state being read. The two legs of the
|
|
// role disagree about the error they raise for it — one a bare
|
|
// fmt.Errorf, one ErrSelfDependency — so refusing at the edge is also
|
|
// what makes the answer the same whichever backend served it.
|
|
if *wire.ParentId == id {
|
|
return refuse("parent_id", "`parent_id` names this issue; an issue cannot be its own parent")
|
|
}
|
|
patch.ParentID = issueops.Field[string]{Set: true, Value: *wire.ParentId}
|
|
}
|
|
if set("metadata") {
|
|
// applyMetadataPatch, unchanged and not respelled: the replace/merge/
|
|
// set/unset algebra is one definition, and a second copy here would be a
|
|
// second one. `set` in particular has to be read RAW so a key written to
|
|
// JSON null survives — see that function.
|
|
metadata, res := applyMetadataPatch(patchParam("metadata")+".", fields["metadata"])
|
|
if res != nil {
|
|
s.fail(w, r, *res)
|
|
return issueops.IssuePatch{}, false
|
|
}
|
|
patch.Metadata = metadata
|
|
}
|
|
// THE THREE LABEL MEMBERS ARE ONE PATCH, assembled together because the role
|
|
// models them as one: LabelPatch applies Replace, then Add, then Remove, so
|
|
// removal wins where a label appears in more than one of them. They are NOT
|
|
// mutually exclusive, which is the difference from `notes`/`append_notes`
|
|
// above — that pair is a contradiction the role refuses, and this trio has a
|
|
// defined order.
|
|
//
|
|
// Building the value in one place is what keeps the wire from inventing a
|
|
// fourth combination rule: a member decoded into its own LabelPatch would
|
|
// overwrite the others' fields, and the last one written would silently win.
|
|
labelEdit := issueops.LabelPatch{}
|
|
for _, member := range []struct {
|
|
name string
|
|
values *[]string
|
|
apply func([]string)
|
|
}{
|
|
// COMPLETE REPLACEMENT, and an empty array clears every label — which is
|
|
// why this sets Replace rather than Add.
|
|
{"labels", wire.Labels, func(v []string) {
|
|
labelEdit.Replace = issueops.Field[[]string]{Set: true, Value: v}
|
|
}},
|
|
{"add_labels", wire.AddLabels, func(v []string) { labelEdit.Add = v }},
|
|
{"remove_labels", wire.RemoveLabels, func(v []string) { labelEdit.Remove = v }},
|
|
} {
|
|
if !set(member.name) {
|
|
continue
|
|
}
|
|
values := *member.values
|
|
// The role refuses an over-long label on ANY of the three and writes
|
|
// nothing, so the edge refuses it on all three too. It is a rule about
|
|
// what a label may BE rather than about whether this row carries one,
|
|
// which is why `remove_labels` is bounded like the other two even though
|
|
// a value the column could not hold could never have been stored.
|
|
for i, label := range values {
|
|
if types.CheckFieldLen("label", label) != nil {
|
|
return refuse(member.name, fmt.Sprintf("`%s[%d]` is %d characters; storage holds at most %d",
|
|
member.name, i, utf8.RuneCountInString(label), types.MaxFieldLen))
|
|
}
|
|
}
|
|
member.apply(values)
|
|
}
|
|
patch.Labels = labelEdit
|
|
|
|
// The four nullable members. Set is true whenever the member is present;
|
|
// the VALUE is a nil pointer for an explicit null, which is how a clear
|
|
// reaches the role.
|
|
if set("estimated_minutes") {
|
|
patch.EstimatedMinutes = issueops.Field[*int]{Set: true, Value: wire.EstimatedMinutes}
|
|
}
|
|
if set("external_ref") {
|
|
if ref := wire.ExternalRef; ref != nil && types.CheckFieldLen("external_ref", *ref) != nil {
|
|
return refuse("external_ref", fmt.Sprintf("`external_ref` is %d characters; storage holds at most %d",
|
|
utf8.RuneCountInString(*ref), types.MaxFieldLen))
|
|
}
|
|
patch.ExternalRef = issueops.Field[*string]{Set: true, Value: wire.ExternalRef}
|
|
}
|
|
if set("due_at") {
|
|
patch.DueAt = issueops.Field[*time.Time]{Set: true, Value: wire.DueAt}
|
|
}
|
|
if set("defer_until") {
|
|
patch.DeferUntil = issueops.Field[*time.Time]{Set: true, Value: wire.DeferUntil}
|
|
}
|
|
return patch, true
|
|
}
|
|
|
|
// isJSONNull reports whether a raw member is the literal `null`.
|
|
func isJSONNull(raw json.RawMessage) bool {
|
|
return bytes.Equal(bytes.TrimSpace(raw), []byte("null"))
|
|
}
|
|
|
|
// patchParam names a patch member the way a client reads it back off `param`:
|
|
// qualified by the member that carries it, so `patch.title` is unambiguous
|
|
// against a request-level member of the same name.
|
|
func patchParam(member string) string {
|
|
if member == "" {
|
|
return updatePatchMember
|
|
}
|
|
return updatePatchMember + "." + member
|
|
}
|
|
|
|
// failUpdate answers a failed update, mapping the role's TYPED refusals onto
|
|
// the frozen codes and its own validation refusal onto the 400 the document
|
|
// promises.
|
|
//
|
|
// EVERY 409 BRANCH READS TYPED FIELDS, never prose, and every one of them is
|
|
// matched BEFORE the ErrValidation and ErrNotFound arms. That order is the
|
|
// whole correctness of this function, and the hazard it avoids is worse than a
|
|
// disagreement between backends: NEITHER LEG WRAPS THESE SIX FAMILIES IN
|
|
// ErrValidation. The store legs return ExecuteUpdate's error through
|
|
// runIssueOperationTx unchanged (internal/storage/dolt/issue_operations.go) and
|
|
// the unit of work returns ApplyUpdate's unchanged
|
|
// (internal/storage/uow/issue_operations.go), so a precondition miss, a close-
|
|
// policy refusal, the assignee fence, the notes-overwrite fence and both graph
|
|
// refusals reach here as bare sentinels. Below the ErrValidation arm they
|
|
// would all fall into `!Is(...)` and be swallowed into failErr — a generic
|
|
// 500, on BOTH legs, for six conditions this document names by code.
|
|
//
|
|
// NEITHER BRANCH QUOTES THE ROLE'S MESSAGE. A refusal from the workspace's
|
|
// configured vocabulary arrives as prose about statuses and types, and a
|
|
// refused edge as a driver error naming tables and constraints; 4xx details on
|
|
// this surface reflect the caller's own input back rather than server
|
|
// internals. The real error goes to the log with the request id.
|
|
//
|
|
// The ErrNotFound arm is LAST among the misses and means the PATH id, which is
|
|
// the divergence from failBatchCreate: this operation addresses a resource, so
|
|
// an id that names nothing is a genuine 404. A missing new PARENT is not that —
|
|
// it is an edge endpoint, and it is a 400 on `patch.parent_id`, conforming to
|
|
// POST /v0/beads/dependencies:add.
|
|
func (s *Server) failUpdate(w http.ResponseWriter, r *http.Request, request issueops.UpdateRequest, err error) {
|
|
var (
|
|
typeConflict *issueops.DependencyTypeConflictError
|
|
hierarchy *issueops.DependencyHierarchyConflictError
|
|
endpoint *issueops.DependencyEndpointNotFoundError
|
|
openChildren *issueops.CloseOpenChildrenError
|
|
claimed *issueops.ClaimConflictError
|
|
)
|
|
// The 4xx path does not log by default, so the refusals whose real reason
|
|
// the response replaces with the server's own words are recorded here.
|
|
refused := func() {
|
|
s.event("request_refused", "request_id", requestInfo(r.Context()).id, "error", err.Error())
|
|
}
|
|
named := func(res Result, param string) Result {
|
|
res.Problem.Param = ¶m
|
|
return res
|
|
}
|
|
|
|
switch {
|
|
case errors.Is(err, issueops.ErrVersionMismatch),
|
|
errors.Is(err, issueops.ErrStatusMismatch),
|
|
errors.Is(err, issueops.ErrAssigneeMismatch):
|
|
s.fail(w, r, updatePreconditionResult(request, err))
|
|
|
|
// A REFUSED CLAIM, answered exactly as `{id}:claim` answers it —
|
|
// `already_claimed` with the holder, `not_claimable` with the status — and
|
|
// naming `claim`, the member that earned it. Matched BEFORE the assignee
|
|
// fence's arm below, which shares the `already_claimed` sentinel but blames
|
|
// `patch.assignee` and steers toward a force this request cannot send.
|
|
case request.Claim && (errors.Is(err, storage.ErrAlreadyClaimed) || errors.Is(err, storage.ErrNotClaimable)):
|
|
s.fail(w, r, named(claimRefusal(err), updateClaimMember))
|
|
|
|
case errors.Is(err, issueops.ErrCloseOpenChildren):
|
|
res := named(newResult(CodeNotClosable,
|
|
"`patch.status` closes an issue with open children; close them first, or send `force_close_policy`"),
|
|
patchParam("status"))
|
|
if errors.As(err, &openChildren) {
|
|
res = res.WithOpenChildren(openChildren.OpenChildren)
|
|
}
|
|
s.fail(w, r, res)
|
|
|
|
case errors.Is(err, issueops.ErrCloseBlocked):
|
|
// No `open_children` member, and its ABSENCE is what tells a client
|
|
// which of the two close-policy refusals it got.
|
|
s.fail(w, r, named(closeBlockedResult(err,
|
|
"`patch.status` closes a blocked issue", "clear the blocker, or send `force_close_policy`"),
|
|
patchParam("status")))
|
|
|
|
case errors.Is(err, storage.ErrAlreadyClaimed):
|
|
res := named(newResult(CodeAlreadyClaimed,
|
|
"`patch.assignee` transfers work away from a live foreign owner; send `force_assignee_transfer`, or guard with `expected_assignee`"),
|
|
patchParam("assignee"))
|
|
// The assignee fence refuses without naming the holder
|
|
// (AuthorizeAssigneeTransferWithPools), so these members are attached
|
|
// only when an implementation did report one. Absent means "re-read the
|
|
// row", never "nobody holds it".
|
|
if errors.As(err, &claimed) {
|
|
if claimed.Assignee != "" {
|
|
res = res.WithAssignee(claimed.Assignee)
|
|
}
|
|
if claimed.Status != "" {
|
|
res = res.WithIssueStatus(string(claimed.Status))
|
|
}
|
|
}
|
|
s.fail(w, r, res)
|
|
|
|
case errors.Is(err, storage.ErrNotesOverwrite):
|
|
s.fail(w, r, named(newResult(CodeNotesOverwrite,
|
|
"`patch.notes` would replace existing non-empty notes; send `force_notes_overwrite`, or use `patch.append_notes` to preserve history"),
|
|
patchParam("notes")))
|
|
|
|
case errors.As(err, &typeConflict):
|
|
s.fail(w, r, named(newResult(CodeDependencyExists,
|
|
"this pair already carries an edge of a different type; remove it before reparenting").
|
|
WithDependencyTypeConflict(typeConflict.ExistingType, typeConflict.RequestedType),
|
|
patchParam("parent_id")))
|
|
|
|
// DEFENSIVE, AND UNREACHABLE TODAY. CheckBlockingHierarchyInTx returns nil
|
|
// for anything but a `blocks` or `conditional-blocks` edge
|
|
// (internal/storage/issueops/dependencies.go), and the only edge this
|
|
// operation writes is the `parent-child` one patch.parent_id names — on both
|
|
// legs, since the unit of work reaches the same function through
|
|
// depRepo.Insert's ValidateBlockingHierarchy. The document says so and tells
|
|
// clients not to dispatch on these members here.
|
|
//
|
|
// The arm stays because of what its ABSENCE would cost if that ever changes:
|
|
// a hierarchy refusal reaching this handler would otherwise fall into the
|
|
// plain-cycle arm below and be answered with the same code carrying NO
|
|
// members, which is the one shape a client reading the discriminator cannot
|
|
// tell from a scheduling cycle. Publishing a member is free; losing one
|
|
// silently is not.
|
|
case errors.As(err, &hierarchy):
|
|
s.fail(w, r, named(newResult(CodeDependencyCycle,
|
|
"this reparent would put the issue under its own descendant, or gate it on its own ancestor").
|
|
WithHierarchyConflict(hierarchy.IssueID, hierarchy.BlockerID, hierarchy.BlockerIsAncestor),
|
|
patchParam("parent_id")))
|
|
|
|
// THE ARM EVERY REPARENT CYCLE ACTUALLY TAKES, carrying no hierarchy
|
|
// members. CheckDependencyCycleInTx does cover parent-child — it is a
|
|
// scheduling edge — so a move under the issue's own descendant lands here.
|
|
case errors.Is(err, issueops.ErrDependencyCycle):
|
|
s.fail(w, r, named(newResult(CodeDependencyCycle,
|
|
"this reparent would create a dependency cycle; nothing was written"),
|
|
patchParam("parent_id")))
|
|
|
|
// An edge endpoint, not the resource this request addresses: the 400 that
|
|
// conforms to POST /v0/beads/dependencies:add. It is matched before the
|
|
// generic ErrNotFound so a missing PARENT can never be reported as a missing
|
|
// ISSUE, which would send a client looking for the wrong row.
|
|
case errors.As(err, &endpoint):
|
|
refused()
|
|
s.fail(w, r, InvalidArgument(patchParam("parent_id"), ReasonInvalidValue,
|
|
"`parent_id` names no issue this workspace holds; nothing was written"))
|
|
|
|
case errors.Is(err, storage.ErrNotFound):
|
|
s.fail(w, r, NotFound())
|
|
|
|
case !errors.Is(err, storage.ErrValidation):
|
|
s.failErr(w, r, err)
|
|
|
|
default:
|
|
refused()
|
|
s.fail(w, r, InvalidArgument(updatePatchMember, ReasonInvalidValue,
|
|
"a patch value was refused by this workspace's own validation; nothing was written"))
|
|
}
|
|
}
|
|
|
|
// updatePreconditionResult builds the 409 for a guard that missed, naming the
|
|
// guard member and echoing what the request asked for.
|
|
//
|
|
// applyPreconditionResult's rule unchanged: the expected value comes from the
|
|
// REQUEST rather than from a read, and the observed value is absent, because
|
|
// the refusal rolled its transaction back and a read afterwards would describe
|
|
// a row the refusal never saw. See PreconditionFailed.
|
|
func updatePreconditionResult(request issueops.UpdateRequest, err error) Result {
|
|
res := PreconditionFailed()
|
|
switch {
|
|
case errors.Is(err, issueops.ErrVersionMismatch):
|
|
res.Problem.Param = updateGuardParam("expected_version")
|
|
if request.ExpectedVersion != nil {
|
|
res = res.WithExpectedVersion(*request.ExpectedVersion)
|
|
}
|
|
case errors.Is(err, issueops.ErrStatusMismatch):
|
|
res.Problem.Param = updateGuardParam("expected_status")
|
|
if request.ExpectedStatus != nil {
|
|
res = res.WithExpectedStatus(string(*request.ExpectedStatus))
|
|
}
|
|
default:
|
|
res.Problem.Param = updateGuardParam("expected_assignee")
|
|
if request.ExpectedAssignee != nil {
|
|
res = res.WithExpectedAssignee(*request.ExpectedAssignee)
|
|
}
|
|
}
|
|
return res
|
|
}
|
|
|
|
// updateGuardParam names a request-level guard member for `param`. The guards
|
|
// sit BESIDE `patch` rather than inside it, so they are spelled bare where a
|
|
// patch member is qualified by patchParam.
|
|
func updateGuardParam(member string) *string { return &member }
|