* fix(metadata): restore v1.2.2 scalar typing for --set-metadata values8ebd53e88moved the CLI's metadata-edit helpers into internal/storage/metadata.go and, in the move, replaced v1.2.2's toJSONValue inference with a MetadataEditValue that always json.Marshals the value as a string. The intent was GH#4146 (a numeric-looking id or a version like "1e3" came back as a JSON number, breaking map[string]string Go consumers), but it silently changed the shipped CLI contract: `bd update --set-metadata k=5` started storing "5" instead of 5. That regression shipped only in the deprecated/superseded v1.2.1, never in v1.2.2, and 1.3.0 would freeze it. Restore v1.2.2's inference body-for-body inside MetadataEditValue, so the parity claim stays checkable against `git show v1.2.2:cmd/bd/update.go`: "null" is JSON null, "true"/"false" are booleans, a spelling that scans as a float AND is valid JSON on its own is emitted as that literal (5 -> 5, 1e3 -> 1e3, 0.50 -> 0.50, while 05, +5 and NaN stay strings), and everything else is a string. Every --set-metadata caller funnels through this one function: embedded (cmd/bd/update.go -> storage.ApplyMetadataEdits), proxied (parseSetMetadataFlags) and the update executor's []string path. GH#4146's concern is served by the explicitly typed routes, which are untouched: --metadata / --metadata-json on the CLI (MergeMetadataJSON) and the typed set map on the HTTP/Go path (applyTypedMetadataEdits). No data migration: a "5" written by an in-window build is indistinguishable from a string a user set intentionally through the typed paths, so normalizing stored metadata would corrupt intended data. Re-running the same --set-metadata k=5 retypes any given key. Tests: new table in internal/storage/metadata_edit_value_test.go pinning the v1.2.2 matrix plus an ApplyMetadataEdits end-to-end; the tests that pinned the string-always behavior are flipped (domain/db mergeops suite, update_lifecycle patch mapping, cmd/bd toJSONValue table) and the embedded + proxied CLI suites now assert a stored JSON number. The contract corpus is regenerated: its update/list/ready goldens run `--set-metadata phase=2`, so `"phase": "2"` becomes `"phase": 2` and nothing else moves. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * fix(create): echo full-precision timestamps from bd create, not the DATETIME(0) re-readb92442d1arouted `bd create` through issueops.Lifecycle, whose executors build their result by re-reading the row they just wrote (HydrateIssueOperationResult -> GetIssueInTx). created_at/updated_at are DATETIME(0) columns, so that snapshot comes back at whole-second precision and cmd/bd/create.go echoes it. v1.2.2 returned the caller's own in-memory struct, which PrepareIssueForInsert stamps with time.Now().UTC() including nanoseconds, so `bd create --json` used to print e.g. 2026-08-28T12:34:56.789012345Z. Agents that create several issues in a burst order them by exactly that fraction; rounded to the second they all tie. Restore the echo with OverlayCreateTimestamps: after hydration, put back the created_at/updated_at (and closed_at, when the write set one) the INSERT actually sent. Everything else on the snapshot stays DB-truth, which is the facade's contract — only create, and only these fields. Applied at every create body, not just the two the CLI reaches: issueops.ExecuteCreate and ExecuteCreateBatch behind the dolt and embedded-dolt stores, and the unit-of-work provider's own Create, CreateBatch and batch-apply create item, which is what the proxied server and POST /v0/beads/issues run on. Fixing only the shared executors would have left the two bodies disagreeing about the same promise. What is NOT changed, because it is not a regression: `bd show --json` and `bd list --json` answered whole seconds in v1.2.2 too — they read the column — and update/close/reopen re-read after writing there as well. Widening the columns to DATETIME(6) would give reads sub-second times too, but that is a schema migration on user Dolt DBs and touches paths that deliberately compare at second precision; it is a 1.4 change. The accepted skew, which predates this and stays: the engine ROUNDS to the column rather than truncating, so a later read of the same row can sit up to half a second either side of the create echo. Tests: two new conformance cases, run on all three backends — RunLifecycleCreateEchoesSubSecondTimestamps (a caller-supplied nanosecond stamp must survive to the result exactly; the auto-stamped arm stays a bounded smoke check, since requiring a non-zero fraction off the clock is flaky by a billionth) and RunBatchCreatorEchoesSubSecondTimestamps (per item, since both bodies build the result one snapshot at a time). Plus a cmd/bd embedded test asserting `bd create --json` prints a fractional part, and one httpapi assertion that the wire does not round the role's snapshot on the way out. All four fail on the pre-fix tree. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * fix(httpapi,types)!: revision / expected_version tokens are opaque JSON strings The optimistic-concurrency token is minted by freshRowLock over the FULL int64 range (crypto-random, non-zero) and published on the wire as a JSON number: `revision` on responses, `expected_version` on guarded requests. A JSON number does not survive a consumer that decodes into an IEEE-754 double — JavaScript's JSON.parse, Go's `any`, Python's `float`, jq. Live tokens run past 5e17, where a double's ulp is already 64, so such a client reads back a value NEAR the token, echoes that as its guard, and earns a 409 against a row nobody else touched. The spec already carried "DECODE IT AS A 64-BIT INTEGER" paragraphs telling clients to work around this; that is a workaround for a wire type that should not have been a number. Emit and accept the token as a decimal STRING instead. It is documented as opaque and EQUALITY-ONLY — compare it, never order or interpret it — and a string round-trips exactly in every JSON consumer. It also leaves a future backend free to mint a token that is not an int64 at all. Internals are untouched: freshRowLock, the row_lock BIGINT column, its migration, types.Issue.RowVersion and the ExpectedVersion *int64 guards on the issueops requests all stay int64. Only the wire projection moves, through the one spelling of the encoding — types.RevisionToken and types.ParseRevisionToken. STRICT STRING ONLY, with no transitional number-or-string acceptance. This API already refuses unknown members by name and keeps one spelling of the guard, and a number is precisely the shape a double-based client has already rounded before it left the client — accepting it would preserve the defect. A numeric guard is a 400 naming the member. Chosen over clamping freshRowLock to 53 bits: a clamp does not fix rows already minted with full-range tokens by in-window builds, so a JS consumer reading one still rounds past 2^53 — repairing that would need a row_lock normalization sweep over issues and wisps, a migration days before a tag. Surface: types.IssueDetails.Revision (what `bd show --json` prints and GET /v0/beads/issues/{id} returns), the five hand-assigned httpapi response fields, applyVersionGuardMember (now the reader for the batch update item too, ahead of its typed decode, so a mistyped token still earns a 400 naming the member), Problem.expected_version, and 14 OpenAPI members regenerated through `make api-gen`. actual_version goes with them — it is documented as "the `revision` the row was found holding", so leaving it an integer would make the expected/actual pair disagree about its own type; it is declared but never populated, so nothing changes behaviorally. Nothing shipped in a tagged release ever carried this member: v1.2.2 has no internal/httpapi at all and no `revision` anywhere on the wire, so the whole surface is in-window and can still be changed compatibly. Legacy migration-0054 rows read as the string "0" with the same CAS semantics. Corpus goldens are UNCHANGED: the canonicalizer already replaced any `revision` value with the string "<REVISION>" whatever its JSON type. Tests: types-level pins that the marshaled member matches `"revision": "-?\d+"` and that RevisionToken/ParseRevisionToken round-trip MinInt64, MaxInt64 and 2^53+1, plus a JS-realistic decode of 2^53+1 with a float64 control proving the token really is one a number would corrupt; httpapi refusal tests for a numeric guard on update, close, reopen, delete and both batch item kinds; a 409 echo asserted as the string; and the proxied serve integration tests now splice the response's own token back in verbatim rather than re-rendering a parsed one. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> --------- Co-authored-by: Claude Fable 5 <noreply@anthropic.com>
103 lines
3.4 KiB
Go
103 lines
3.4 KiB
Go
package main
|
|
|
|
import (
|
|
"encoding/json"
|
|
"strings"
|
|
"testing"
|
|
|
|
"github.com/steveyegge/beads/internal/types"
|
|
)
|
|
|
|
// TestIssueDetailsCountOnlyJSON is the regression guard for be-ijck6q:
|
|
// the default bd show --json output must emit dependent_count / comment_count
|
|
// as count-only fields and must NOT include a "dependents" or "comments" key
|
|
// when --include-dependents / --include-comments are not given.
|
|
func TestIssueDetailsCountOnlyJSON(t *testing.T) {
|
|
depCount := int64(42)
|
|
depnCount := int64(3)
|
|
cmtCount := int64(7)
|
|
details := &types.IssueDetails{
|
|
Issue: types.Issue{
|
|
ID: "be-abc",
|
|
Title: "Test issue",
|
|
},
|
|
DependentCount: &depCount,
|
|
DependencyCount: &depnCount,
|
|
CommentCount: &cmtCount,
|
|
// Dependents and Comments intentionally nil (count-only mode)
|
|
}
|
|
|
|
data, err := json.Marshal(details)
|
|
if err != nil {
|
|
t.Fatalf("marshal: %v", err)
|
|
}
|
|
js := string(data)
|
|
|
|
// Count fields must be present.
|
|
if !strings.Contains(js, `"dependent_count":42`) {
|
|
t.Errorf("expected dependent_count:42 in JSON, got: %s", js)
|
|
}
|
|
if !strings.Contains(js, `"dependency_count":3`) {
|
|
t.Errorf("expected dependency_count:3 in JSON, got: %s", js)
|
|
}
|
|
if !strings.Contains(js, `"comment_count":7`) {
|
|
t.Errorf("expected comment_count:7 in JSON, got: %s", js)
|
|
}
|
|
|
|
// Slice fields must be absent (omitempty, nil → omitted).
|
|
if strings.Contains(js, `"dependents"`) {
|
|
t.Errorf("expected no dependents key in count-only output, got: %s", js)
|
|
}
|
|
if strings.Contains(js, `"comments"`) {
|
|
t.Errorf("expected no comments key in count-only output, got: %s", js)
|
|
}
|
|
}
|
|
|
|
// TestShowJSONDetailsCarryTheRevisionToken pins what `bd show --json` puts on
|
|
// the wire, from the type the command now marshals directly.
|
|
//
|
|
// The CLI-only projection wrapper this used to test is gone: the token is a
|
|
// field of types.IssueDetails, set by types.NewIssueDetails, and both front
|
|
// doors get it from the one detail seam. What is still worth asserting HERE is
|
|
// the CLI's half of the deal — that the command marshals a detail view built
|
|
// through that constructor and that no storage spelling rides along with it.
|
|
func TestShowJSONDetailsCarryTheRevisionToken(t *testing.T) {
|
|
for _, tc := range []struct {
|
|
name string
|
|
token int64
|
|
want string
|
|
}{
|
|
{"a mutated row", 123456789, `"revision":"123456789"`},
|
|
// 0 is the migration-0054 backfill token, a legitimate CAS value a
|
|
// guarded client must be able to read. No omitempty, so it is emitted
|
|
// rather than standing in for "this producer has no token", and it is
|
|
// the STRING "0" rather than the number.
|
|
{"a legacy un-mutated row", 0, `"revision":"0"`},
|
|
// The token this spelling exists for: 2^53+1 is the smallest int64 a
|
|
// double-based `jq`/JavaScript consumer of `bd show --json` cannot
|
|
// hold.
|
|
{"a token past 2^53", 9007199254740993, `"revision":"9007199254740993"`},
|
|
} {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
details := types.NewIssueDetails(types.Issue{
|
|
ID: "be-revision",
|
|
Title: "Versioned issue",
|
|
RowVersion: tc.token,
|
|
})
|
|
|
|
data, err := json.Marshal(details)
|
|
if err != nil {
|
|
t.Fatalf("marshal: %v", err)
|
|
}
|
|
js := string(data)
|
|
if !strings.Contains(js, tc.want) {
|
|
t.Errorf("expected %s in show JSON, got: %s", tc.want, js)
|
|
}
|
|
for _, forbidden := range []string{"row_version", "RowVersion", "row_lock"} {
|
|
if strings.Contains(js, forbidden) {
|
|
t.Errorf("show JSON leaked storage field %q: %s", forbidden, js)
|
|
}
|
|
}
|
|
})
|
|
}
|
|
}
|