beads/internal/storage/issueops/create_batch.go
Julian Knutsen 1f1e82ab08
fix(issueops): one default priority for every create path (#7426)
* fix(issueops): one create priority default; HTTP absent priority is P2

The CLI defaulted `bd create` to P2, but issues:create, issues:batchCreate
and batch:apply create items left Issue.Priority at 0 when `priority` was
absent, so a gc/curl create stored P0 (critical) against the spec's "absent
means the default".

The default now lives in one place, the shared create preparation
(PreparePublicCreateRequest), behind a presence flag because Issue.Priority's
zero value is P0:
- issueops.CreateRequest.DefaultPriority, BatchCreateItem.DefaultPriority and
  CreateItem.DefaultPriority ask for issueops.DefaultCreatePriority (2);
  setting it with a non-zero priority is ErrValidation
  (ValidateCreatePriority, shared with the HTTP client);
- every Lifecycle.Create, BatchCreator and BatchApplier leg (dolt, embedded,
  uow) reaches it; CloneCreateBatchRequest now keeps scalar item members;
- the three handlers set the flag for an absent member and never make up 0;
  the HTTP client omits `priority` for it (wirePriority) only when the
  server advertises the new additive issues.create.defaultPriority token,
  read from the cached handshake before the dial; an older server reads an
  absent priority as P0, so the client sends DefaultCreatePriority (2)
  explicitly to it (pinCreateDefaultPriority). An explicit 0 is still sent;
- `bd create` without --priority, `bd create --graph` nodes without priority
  and `bd create --file` templates without ### Priority rely on the flag; the
  flag's displayed default and the dry-run previews read the library
  constant. CLI output is byte-identical (checked against origin/main).

Spec: the three priority descriptions now say the create default is P2 on
a server advertising issues.create.defaultPriority (apigen regenerated); the
wireshape golden already had priority optional, so no wire-shape change.

Conformance: RunLifecycleCreateAppliesTheDefaultPriority,
RunBatchCreatorAppliesTheDefaultPriority and
RunBatchApplyAppliesTheDefaultPriority on dolt, embedded, uow and http, plus
handler and client encoding tests, and
TestCreateSendsTheDefaultPriorityToAServerThatPredatesIt (new client,
handshake without the token: all three create roles send 2).

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

* fix(issueops): apply review fixups for the default create priority (bd-kb61wg)

Apply the minor and nit findings from the review of #7426:

- CHANGELOG: tell out-of-tree storage backends they must honor
  DefaultPriority (store issueops.DefaultCreatePriority, refuse it with a
  non-zero priority as ErrValidation) and which conformance cases check
  it; scope "CLI output is unchanged" to the in-tree backends.
- bd create --file: pin the default-priority path. The e2e test asserts
  the printed priorities, and a buildMarkdownBatchRequest unit test pins
  the flag and priority for an absent, a 0 and a 1 `### Priority`.
  Deleting `DefaultPriority: !template.PrioritySet` now fails both.
- bd create --file: warn on stderr about a `### Priority` that does not
  parse, as the `### Type` case already does, instead of dropping it
  silently.
- httpclient: document pinCreateDefaultPriority's same-build assumption
  (the handshake is cached per Store, so a stale one is silent here), and
  test its no-context and failed-handshake branches on all three roles.
- Formula steps, `bd q` and `bd todo add` spell
  issueops.DefaultCreatePriority instead of the literal 2.
- Conformance: the batch-creator and batch-apply default-priority cases
  also pin DefaultPriority with a non-zero priority as ErrValidation with
  nothing written.

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

* fix(issueops): mark the out-of-tree DefaultPriority change BREAKING (bd-0tcn1o)

Apply the minor findings from the relaunch review of #7426:

- CHANGELOG: move the obligation on out-of-tree storage backends out of
  the `### Fixed` entry into its own `### Changed` entry, led by
  "BREAKING (out-of-tree storage backends)" as the close-guard change
  and the earlier out-of-tree contract changes are; RELEASING.md asks
  breaking changes to carry their migration. The entry says what such a
  backend used to receive from `bd create`, `--graph` and `--file`
  (priority 2), what it receives now (priority 0 with DefaultPriority
  set), the migration, and the conformance cases that check it. The
  `### Fixed` entry keeps the HTTP P2 fix, points at the new entry, and
  names the stale-handshake residual that only a code comment named: a
  create that lands on an older build behind the same URL still stores
  P0.
- bd cook: the proto root, the gate issue and the cooked formula root
  spell issueops.DefaultCreatePriority instead of the literal 2, as the
  formula steps in the same file already do. No behavior change.

Not taken:
- The literal 2s in create_form.go, gate.go and linear.go, and the
  "default 2" in todo.go's --priority help: explicit P2s outside the
  migrated paths (the help string also feeds the generated CLI
  reference). Left for a follow-up sweep.
- Reusing in.priorityDefault in the direct bd create route: that route
  builds no createInput (gatherCreateInput runs only on the proxied and
  --file routes, and each returns), so there is nothing to reuse.
- A member-level range check in the single-create HTTP decode, as the
  batch shapes have: the asymmetry predates this PR, and the role still
  refuses an out-of-range priority on all three shapes.

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 01:37:27 +00:00

252 lines
10 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"
)
// CloneCreateBatchRequest returns a deep copy of request, so a body can
// normalize an attempt without writing through to the caller's items — and, in
// particular, without leaving the ID it assigned on the caller's issue.
func CloneCreateBatchRequest(request publicops.CreateBatchRequest) publicops.CreateBatchRequest {
clone := request
clone.Items = make([]publicops.BatchCreateItem, len(request.Items))
for i, item := range request.Items {
// Start from the item itself so every scalar member (DefaultPriority
// today) survives the clone; only the reference members are deepened.
clone.Items[i] = item
clone.Items[i].Issue = clonePublicIssue(item.Issue)
clone.Items[i].Dependencies = append([]publicops.CreateDependency(nil), item.Dependencies...)
}
return clone
}
// ValidateCreateBatchRequest applies the request rules every BatchCreator
// implementation shares. It runs BEFORE any transaction opens: everything it
// checks is knowable from the request alone, so a batch refused here has
// provably written nothing.
//
// Per-item CONTENT rules are not here. They need the workspace's configured
// prefix, statuses and types, so they run inside the transaction through the
// same PreparePublicCreateRequest a single create runs.
func ValidateCreateBatchRequest(request publicops.CreateBatchRequest) error {
if request.Actor == "" {
return fmt.Errorf("%w: create batch requires an actor", storage.ErrValidation)
}
if len(request.Items) == 0 {
return fmt.Errorf("%w: create batch requires at least one item", storage.ErrValidation)
}
for i, item := range request.Items {
if item.Issue == nil {
return fmt.Errorf("%w: create batch item %d requires an issue", storage.ErrValidation, i)
}
}
return nil
}
// CreateBatchItemRequest projects one item onto the single-create request the
// shared preparation and validation speak. Both front doors and both bodies read
// an item through it, so no item restates CreateRequest's field rules.
func CreateBatchItemRequest(request publicops.CreateBatchRequest, item publicops.BatchCreateItem) publicops.CreateRequest {
return publicops.CreateRequest{
Actor: request.Actor,
Issue: item.Issue,
Dependencies: item.Dependencies,
ForceIDPrefix: request.ForceIDPrefix,
DefaultPriority: item.DefaultPriority,
}
}
// CreateBatchItemError names the item a batch refusal came from. The role
// promises the index appears in the message and nowhere else.
func CreateBatchItemError(index int, err error) error {
return fmt.Errorf("create batch item %d: %w", index, err)
}
// CreateBatchCommitMessage is the history entry a batch records: the caller's
// own label when it supplied one, otherwise a default naming how much landed.
//
// IT NAMES A COUNT AND NEVER AN ID: a create batch's ids are new, there can be
// hundreds from one file, and an entry naming them all is the diff written twice.
//
// An all-ephemeral batch writes only to the dolt-ignored wisp tables, so the
// store-backed bodies stage nothing and record no entry whatever this returns —
// but the unit-of-work backend reads "" as "roll this attempt back", so a
// wisp-only batch must still hand it a message or the wisps it created are
// discarded. That is the same trap CloseBatchCommitMessage documents.
func CreateBatchCommitMessage(request publicops.CreateBatchRequest, result publicops.CreateBatchResult) string {
durable, ephemeral := 0, 0
for _, issue := range result.Issues {
if IsWisp(issue) {
ephemeral++
continue
}
durable++
}
var fallback string
switch {
case durable > 0:
fallback = fmt.Sprintf("bd: create %d issue(s)", durable)
case ephemeral == 1:
fallback = "bd: create 1 ephemeral item"
case ephemeral > 1:
fallback = fmt.Sprintf("bd: create %d ephemeral items", ephemeral)
default:
return ""
}
return HistoryEntry(request.Provenance, fallback)
}
// ExecuteCreateBatch creates every item in tx and reports the durable tables
// changed. It is the store-backed body behind the BatchCreator accessor.
//
// THE ITEMS ARE PREPARED FIRST AND WRITTEN ONCE. Each goes through the same
// PreparePublicCreateRequest a single create goes through, and each is assigned
// its id before any row is written, which is what lets an item's edge name an
// item created earlier in the same batch. The rows and their edges then land
// through ONE CreateIssuesInTxWithResult.
//
// ANY error returns, and the enclosing transaction rolls the whole batch back.
// That includes an edge the engine declined to write: the batch engine drops a
// dangling edge so a partial import can still land, and this role refuses.
func ExecuteCreateBatch(ctx context.Context, tx *sql.Tx, request publicops.CreateBatchRequest) (publicops.CreateBatchResult, ChangedTables, error) {
attempt := CloneCreateBatchRequest(request)
if err := ValidateCreateBatchRequest(attempt); err != nil {
return publicops.CreateBatchResult{}, nil, err
}
options := storage.BatchCreateOptions{
CreateOnly: true,
SkipPrefixValidation: attempt.ForceIDPrefix,
}
batch, err := NewBatchContext(ctx, tx, options)
if err != nil {
return publicops.CreateBatchResult{}, nil, err
}
createContext := PublicCreateContext{
IssuePrefix: batch.ConfigPrefix,
AllowedPrefixes: batch.AllowedPrefixes,
CustomStatuses: batch.CustomStatuses,
CustomTypes: batch.CustomTypes,
}
infraTypes := ResolveInfraTypesInTx(ctx, tx)
issues := make([]*types.Issue, len(attempt.Items))
for i, item := range attempt.Items {
prepared, err := PreparePublicCreateRequest(CreateBatchItemRequest(attempt, item), createContext)
if err != nil {
return publicops.CreateBatchResult{}, nil, CreateBatchItemError(i, err)
}
issue := prepared.Issue
// Configured infra types live in the wisp tables, the same routing
// ExecuteCreate applies. Mark the issue BEFORE its ID is assigned so ID
// generation, the create-only guard and table routing all agree.
if !issue.Ephemeral && !issue.NoHistory && infraTypes[string(issue.IssueType)] {
issue.Ephemeral = true
}
// A wisp_type is a claim of ephemerality, same as ExecuteCreate: a
// typed wisp minted without the flag escapes every TTL/GC/purge tier.
if !issue.Ephemeral && !issue.NoHistory && issue.WispType != "" {
issue.Ephemeral = true
}
if err := assignCreateIssueIDInTx(ctx, tx, batch, issue, attempt.Actor); err != nil {
return publicops.CreateBatchResult{}, nil, CreateBatchItemError(i, ClassifyPublicCreateError(err))
}
issue.Dependencies = storage.CreatePublicCreateDependencies(issue.ID, prepared)
issues[i] = issue
}
var skipped []skippedDependency
options.OnSkippedDependency = func(issueID, dependsOnID, reason string) {
skipped = append(skipped, skippedDependency{issueID: issueID, dependsOnID: dependsOnID, reason: reason})
}
created, err := CreateIssuesInTxWithResult(ctx, tx, issues, attempt.Actor, options)
if err != nil {
return publicops.CreateBatchResult{}, nil, ClassifyPublicCreateError(err)
}
if len(skipped) > 0 {
return publicops.CreateBatchResult{}, nil, publicCreateValidationError(skippedDependencyError(skipped))
}
// CreateIssuesDirtyTables reports the child_counters advance itself, from
// the reconciliation the batch engine already ran, so there is no separate
// counter bookkeeping here.
tables := ChangedTables{}
tables.Merge(CreateIssuesDirtyTables(ctx, issues, created))
result := publicops.CreateBatchResult{Issues: make([]*types.Issue, len(issues))}
for i, issue := range issues {
hydrated, err := HydrateIssueOperationResult(ctx, tx, issue.ID, false)
if err != nil {
return publicops.CreateBatchResult{}, nil, err
}
OverlayCreateTimestamps(hydrated, issue)
result.Issues[i] = hydrated
}
return result, tables, nil
}
// CrossPlaneBatchEdgeError is the refusal the store-backed body raises from
// validateCreateIssuesMixedBucketDependencies, spelled here so the unit-of-work
// body can raise the identical one before it starts writing.
func CrossPlaneBatchEdgeError(sourceID, targetID string) error {
return fmt.Errorf("mixed regular/wisp CreateIssues batch cannot include cross-bucket dependency %s -> %s; create the issues first, then add the in-batch dependency after both issues exist%.0w",
sourceID, targetID, publicops.ErrValidation)
}
// ValidateCreateBatchPlanes refuses a batch whose items would write an edge
// BETWEEN the durable and ephemeral planes, which BatchCreator's contract says
// "cannot be written by the batch that creates both of its ends".
//
// THE STORE BODY GETS THIS FOR FREE and the unit-of-work body does not. The
// store body assigns every id first and then hands the whole slice to
// CreateIssuesInTxWithResult, which sees the batch as a set and refuses. The
// unit-of-work body creates item by item, so by the time an edge is written
// its target is an ordinary existing row and the domain layer writes the
// cross-plane edge happily — the identical request was refused whole by two
// backends and landed in full on the third.
//
// Only an EXPLICIT id can be an in-batch target: a caller cannot name an id the
// batch has not minted yet, so the ids known here are the only ones an edge can
// reach inside the batch. infraTypes promotes the same types both bodies
// promote, so the plane a row lands in is decided the same way it will be.
func ValidateCreateBatchPlanes(request publicops.CreateBatchRequest, infraTypes map[string]bool) error {
wispByID := make(map[string]bool, len(request.Items))
var hasDurable, hasWisp bool
planeOf := func(issue *publicops.Issue) bool {
return issue.Ephemeral || issue.NoHistory || infraTypes[string(issue.IssueType)]
}
for _, item := range request.Items {
if item.Issue == nil {
continue
}
wisp := planeOf(item.Issue)
if wisp {
hasWisp = true
} else {
hasDurable = true
}
if item.Issue.ID != "" {
wispByID[item.Issue.ID] = wisp
}
}
if !hasDurable || !hasWisp {
return nil
}
for _, item := range request.Items {
if item.Issue == nil {
continue
}
source := planeOf(item.Issue)
for _, dep := range item.Dependencies {
target, inBatch := wispByID[dep.TargetID]
if inBatch && source != target {
return CrossPlaneBatchEdgeError(item.Issue.ID, dep.TargetID)
}
}
}
return nil
}