Beads had two implementations of most issue verbs: one for the direct route
(the CLI talking to a store it opened itself) and one for the proxied-server
route (the CLI talking through a unit of work over a running Dolt server).
They drifted — different commit messages, different transaction boundaries,
different refusals, occasionally different answers.
Seven role interfaces now live in the leaf package issueops: Lifecycle,
Reader, ReadyClaimer, BatchCloser, DependencyEditor, Commenter and Relations.
Each is reached only through a store accessor, never a constructor, because
the accessor is where the hook and telemetry decorators add their layers.
Three implementations back every role — dolt, embeddeddolt, and the
unit-of-work provider the proxied route uses. Both routes call the same role
for close, dep add/remove/list, comment, ready --claim and update.
A depguard rule (httpapi-domain-boundary) denies internal/storage/domain from
internal/httpapi, so a handler cannot reach uw.IssueUseCase() past the roles
and open a second front door one lint-clean commit at a time.
Behaviour users will notice, all in the CHANGELOG:
- bd close a b c is one Dolt commit, not three, and --claim-next moved
inside that transaction so it fires only when something landed
- the open-children guard moved into the transaction and its hand-rolled
cmd/bd copy is gone, removing a read-then-write window that made
bd close <child> <parent> depend on argument order
- bd dep add --file honours deferred version commit
- embedded bd comment writes the role's message and author
- dep verb commit messages are the role's on the direct route
Wisp-sourced dependency edges are restored. Moving bd dep add onto the role
had pinned an edge's SOURCE to the issues plane, and the two routes did not
even fail alike: direct refused with "issue <id> not found", proxied threw an
fk_dep_issue violation. The comment justifying the pin claimed the issues
plane was "the only one its unit-of-work sibling can reach" — that was false;
domain.DependencyUseCase declared a full set of wisp twins with no production
caller. All three implementations now route per edge by the edge's own
source. A mixed request stays one transaction: parent-child-first ordering
and the whole-graph cycle gate span both planes, and a refusal rolls back
both. Behind the role, three bulk add verbs collapsed into one source-routed
AddDependencies, so no plane-pinned variant is left to reach for by mistake.
Six Provenance fields with no production caller were deleted rather than
wired — CloseRequest, CloseBatchRequest, ClaimNextRequest, AddCommentRequest,
AddDependenciesRequest, RemoveDependencyRequest. Each role already composes an
id-bearing message, so a caller could only restate the default and make it
unreachable from production. Two are not caller-settable even in principle:
CloseBatchCommitMessage names what LANDED and ClaimNextCommitMessage names the
id the claim WON. UpdateRequest and ReopenRequest keep theirs; commit messages
users see are unchanged.
Verified: build, vet and gofmt clean; golangci-lint 0 issues; protocol corpus
byte-identical under BEADS_PROTOCOL_REQUIRE_DOLT=1; all twelve
DependencyEditor conformance wirings green (four contract functions against
each implementation); TestEmbeddedDepAddWispSource runs bd dep add <wisp-id>
at the front door and was demonstrated RED against the pinned routing first.
Three internal/storage/dolt failures reproduce on pristine origin/main.
Known gaps are enumerated in the PR description rather than left to be found:
comment listing is on no role, bd dep tree and bd dep cycles have no role,
bd create and bd reopen are on Lifecycle only on the direct route, per-edge
line attribution is lost in bd dep add --file, multi-store bd close
--claim-next rides only the first store's batch, and the is_blocked staging gap
(bd-2y9ke, predates this change). Seven of the eight role interfaces now have a
shared conformance contract in backend/conformance, run at all three
implementations; main's Claimer, added in parallel by #5334, is the eighth and
has none yet.
Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
112 lines
4.2 KiB
Go
112 lines
4.2 KiB
Go
package issueops
|
|
|
|
import (
|
|
"context"
|
|
"database/sql"
|
|
"fmt"
|
|
|
|
"github.com/steveyegge/beads/internal/storage"
|
|
"github.com/steveyegge/beads/internal/types"
|
|
publicops "github.com/steveyegge/beads/issueops"
|
|
)
|
|
|
|
// ClaimNextCommitMessage names the claim in the Dolt commit message, matching
|
|
// what the CLI's own per-command commit wrote before the claim moved onto the
|
|
// role. It is the only spelling: the id it names is the one the claim WON, so
|
|
// no caller could have composed it before the call.
|
|
func ClaimNextCommitMessage(issueID string) string {
|
|
return "bd: claim ready " + issueID
|
|
}
|
|
|
|
// ValidateClaimNextRequest applies the request rules every ReadyClaimer
|
|
// implementation shares. It lives here rather than in each of them because a
|
|
// rule enforced on one backend and not the other is not a contract.
|
|
func ValidateClaimNextRequest(request publicops.ClaimNextRequest) error {
|
|
if request.Actor == "" {
|
|
return fmt.Errorf("%w: claim next requires an actor", storage.ErrValidation)
|
|
}
|
|
if request.Filter.Limit != nil {
|
|
return fmt.Errorf("%w: claim next does not take a limit", storage.ErrValidation)
|
|
}
|
|
if request.Filter.Offset != 0 {
|
|
return fmt.Errorf("%w: claim next does not take an offset", storage.ErrValidation)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// ExecuteClaimNext claims the first ready issue matching filter in tx, hydrates
|
|
// it in that same transaction, and reports the durable tables changed.
|
|
//
|
|
// It takes the filter rather than the public request because this package
|
|
// speaks WorkFilter: the request-to-filter translation is internal/workapi's,
|
|
// and the same builder that answers Reader.Ready is what the accessor
|
|
// implementations run before calling in here. That is what keeps the claim's
|
|
// predicate and the listing's predicate the same predicate.
|
|
//
|
|
// A nil claim with a nil error is the ordinary empty-front outcome. It reports
|
|
// no changed tables, so the caller's transaction commits nothing and no
|
|
// history entry is recorded.
|
|
func ExecuteClaimNext(ctx context.Context, tx *sql.Tx, actor string, filter types.WorkFilter) (publicops.ClaimNextResult, ChangedTables, error) {
|
|
claimed, err := ClaimReadyIssueInTx(ctx, tx, filter, actor)
|
|
if err != nil {
|
|
return publicops.ClaimNextResult{}, nil, err
|
|
}
|
|
if claimed == nil {
|
|
return publicops.ClaimNextResult{}, nil, nil
|
|
}
|
|
hydrated, err := HydrateReadyRowInTx(ctx, tx, claimed)
|
|
if err != nil {
|
|
return publicops.ClaimNextResult{}, nil, err
|
|
}
|
|
tables := ChangedTables{}
|
|
tables.Add("issues", "events")
|
|
return publicops.ClaimNextResult{Claimed: hydrated}, tables, nil
|
|
}
|
|
|
|
// HydrateReadyRowInTx fills in the relationship cardinalities a ready row
|
|
// carries, reading them in the caller's transaction so the counts describe the
|
|
// state that transaction is about to commit.
|
|
//
|
|
// A failed count read is an error rather than a zero. The CLI's pre-role
|
|
// hydration swallowed all three, which meant a broken database reported a
|
|
// claimed issue with no dependencies rather than saying the read failed; here
|
|
// the whole claim rolls back instead, because a result nobody can hydrate is
|
|
// not a result.
|
|
func HydrateReadyRowInTx(ctx context.Context, tx *sql.Tx, issue *types.Issue) (*types.IssueWithCounts, error) {
|
|
if issue == nil {
|
|
return nil, nil
|
|
}
|
|
ids := []string{issue.ID}
|
|
depCounts, err := GetDependencyCountsInTx(ctx, tx, ids)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("hydrate ready row %s: dependency counts: %w", issue.ID, err)
|
|
}
|
|
records, err := GetDependencyRecordsForIssuesInTx(ctx, tx, ids)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("hydrate ready row %s: dependency records: %w", issue.ID, err)
|
|
}
|
|
commentCounts, err := GetCommentCountsInTx(ctx, tx, ids)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("hydrate ready row %s: comment counts: %w", issue.ID, err)
|
|
}
|
|
|
|
issue.Dependencies = records[issue.ID]
|
|
counts := depCounts[issue.ID]
|
|
if counts == nil {
|
|
counts = &types.DependencyCounts{}
|
|
}
|
|
var parent *string
|
|
for _, dep := range records[issue.ID] {
|
|
if dep.Type == types.DepParentChild {
|
|
parent = &dep.DependsOnID
|
|
break
|
|
}
|
|
}
|
|
return &types.IssueWithCounts{
|
|
Issue: issue,
|
|
DependencyCount: counts.DependencyCount,
|
|
DependentCount: counts.DependentCount,
|
|
CommentCount: commentCounts[issue.ID],
|
|
Parent: parent,
|
|
}, nil
|
|
}
|