fix(types): one source of truth for issue types across bd types and create (#6934)

bd types and create validation now both resolve custom types through issueops.ComposeCustomTypes in every mode (direct, server, proxied). Server-mode bd types now includes config.yaml types, proxied config set storage-class accepts DB types, and bd types lists the system types (message, molecule, gate, event); JSON gains additive system_types. Custom-type read errors now fail instead of being swallowed.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
Julian Knutsen 2026-09-29 02:10:46 -07:00 • committed by GitHub
commit 2bb5337355
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
14 changed files with 492 additions and 174 deletions

View file

@ -40,6 +40,22 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
statements it cannot parse (for example `PRAGMA`) instead of treating them
as reads.
- **`bd types` now lists exactly the types `bd create --type` accepts**
([#6934](https://github.com/gastownhall/beads/pull/6934)). The two resolved
the type set through different code and could disagree: a server-mode
workspace's `bd types` dropped `.beads/config.yaml` `types.custom` entries
once the database had any custom type, although create accepts them; in
proxied mode `bd config set storage-class.<type>` checked `config.yaml` alone
and refused custom types registered in the database; and the built-in system
types `message`, `molecule`, `gate` and `event` were never listed. Every
mode now composes custom types by one rule (the `custom_types` table, else
the `types.custom` config row, always unioned with `config.yaml`). `bd types`
gains a "System types" section, and `bd types --json` an additive
`system_types` field; `core_types` and `custom_types` are unchanged. A
failure to read the custom types now fails `bd types`, `bd create --graph`
and `bd config set storage-class.*` instead of being silently treated as "no
custom types".
- **`notion.token` is kept out of the Dolt database**
([#6676](https://github.com/gastownhall/beads/issues/6676)). It was missing
from the yaml-only key list that holds the other tracker secrets, so

View file

@ -318,7 +318,6 @@ go_library(
"todo_proxied_server.go",
"tracker_store.go",
"types.go",
"types_proxied_server.go",
"unclaim.go",
"unclaim_proxied_server.go",
"undefer.go",
@ -1102,6 +1101,8 @@ go_test(
"todo_embedded_test.go",
"tracker_frontdoor_proxy_test.go",
"tracker_proxy_uow_conformance_integration_test.go",
"types_builtin_test.go",
"types_create_agreement_test.go",
"types_embedded_test.go",
"unclaim_conditional_embedded_test.go",
"unclaim_conditional_parity_test.go",

View file

@ -1264,7 +1264,11 @@ func validateStorageClassConfig(key, value string) error {
if canonical := issueType.Normalize(); canonical != issueType {
return fmt.Errorf("invalid key %q: %q is an alias of %q, and create-time lookup uses the canonical type; set storage-class.%s instead", key, suffix, canonical, canonical)
}
if !issueType.IsValidWithCustom(loadEmbeddedCustomTypes()) {
customTypes, err := resolveWorkspaceCustomTypes(rootCtx)
if err != nil {
return err
}
if !issueType.IsValidWithCustom(customTypes) {
return fmt.Errorf("invalid key %q: unknown issue type %q (use a built-in type, or add it to types.custom first)", key, suffix)
}
if _, err := types.ParseStorageClass(value); err != nil {

View file

@ -11,7 +11,6 @@ import (
"github.com/spf13/cobra"
"github.com/steveyegge/beads/internal/config"
"github.com/steveyegge/beads/internal/storage"
"github.com/steveyegge/beads/internal/storage/domain"
"github.com/steveyegge/beads/internal/storage/uow"
@ -21,13 +20,6 @@ import (
"github.com/steveyegge/beads/issueops"
)
func resolveProxiedCustomTypes(dbTypes []string) []string {
if len(dbTypes) > 0 {
return dbTypes
}
return config.GetCustomTypesFromYAML()
}
func runCreateProxiedServer(cmd *cobra.Command, ctx context.Context, in createInput) error {
if in.repoOverrideSet {
// Defense in depth: validateProxyCapabilitiesBeforeProvider already
@ -394,7 +386,7 @@ func runCreateProxiedGraph(_ *cobra.Command, ctx context.Context, in createInput
// The returned useWisp is the plan-wide table routing decision.
func validateProxiedGraphPlan(plan *GraphApplyPlan, in createInput, cctx domain.CreateContext, issueExists func(id string) (bool, error)) (useWisp bool, err error) {
cfg := graphPlanConfig{
customTypes: resolveProxiedCustomTypes(cctx.CustomTypes),
customTypes: cctx.CustomTypes,
// No YAML fallback for statuses — the server database is authoritative
// (that's where 'bd config set status.custom' writes) and statuses are
// store-only everywhere (single-issue create, list filters), unlike

View file

@ -3,13 +3,10 @@ package main
import (
"encoding/json"
"fmt"
"os"
"path/filepath"
"reflect"
"testing"
"time"
"github.com/steveyegge/beads/internal/config"
"github.com/steveyegge/beads/internal/types"
"github.com/steveyegge/beads/issueops"
)
@ -473,55 +470,3 @@ func TestParseMarkdownDependencies_DoesNotSwapBlocks(t *testing.T) {
t.Errorf("got %#v, want %#v (no swap-direction)", got, want)
}
}
func TestResolveProxiedCustomTypes_PrefersDBTypes(t *testing.T) {
got := resolveProxiedCustomTypes([]string{"db-a", "db-b"})
if !reflect.DeepEqual(got, []string{"db-a", "db-b"}) {
t.Errorf("got %#v, want [db-a db-b] — DB types must win when non-empty", got)
}
}
func TestResolveProxiedCustomTypes_FallsBackToYAML(t *testing.T) {
restore := withTestYAMLCustomTypes(t, "molecule,gate,convoy")
defer restore()
for _, dbTypes := range [][]string{nil, {}} {
got := resolveProxiedCustomTypes(dbTypes)
if !reflect.DeepEqual(got, []string{"molecule", "gate", "convoy"}) {
t.Errorf("dbTypes=%v: got %#v, want YAML fallback [molecule gate convoy]", dbTypes, got)
}
}
}
func TestResolveProxiedCustomTypes_EmptyEverywhere(t *testing.T) {
restore := withTestYAMLCustomTypes(t, "")
defer restore()
got := resolveProxiedCustomTypes(nil)
if len(got) != 0 {
t.Errorf("expected empty result, got %#v", got)
}
}
func withTestYAMLCustomTypes(t *testing.T, customCSV string) func() {
t.Helper()
tmpDir := t.TempDir()
beadsDir := filepath.Join(tmpDir, ".beads")
if err := os.MkdirAll(beadsDir, 0o755); err != nil {
t.Fatalf("mkdir .beads: %v", err)
}
var content string
if customCSV != "" {
content = "types:\n custom: \"" + customCSV + "\"\n"
}
if err := os.WriteFile(filepath.Join(beadsDir, "config.yaml"), []byte(content), 0o644); err != nil {
t.Fatalf("write config.yaml: %v", err)
}
t.Chdir(tmpDir)
config.ResetForTesting()
if err := config.Initialize(); err != nil {
t.Fatalf("config.Initialize: %v", err)
}
return func() { config.ResetForTesting() }
}

View file

@ -12,7 +12,6 @@ import (
"strings"
"time"
"github.com/steveyegge/beads/internal/config"
"github.com/steveyegge/beads/internal/storage"
"github.com/steveyegge/beads/internal/types"
"github.com/steveyegge/beads/internal/validation"
@ -305,15 +304,6 @@ func warnUnknownGraphFields(w io.Writer, unknown map[string][]string) []string {
return hintFields
}
func loadEmbeddedCustomTypes() []string {
if store != nil {
if ct, err := store.GetCustomTypes(rootCtx); err == nil && len(ct) > 0 {
return ct
}
}
return config.GetCustomTypesFromYAML()
}
// loadEmbeddedCustomStatuses reads custom statuses from the store only — no
// YAML fallback, matching single-issue create and loadListFilterConfig
// (custom types fall back to YAML; custom statuses deliberately do not).
@ -348,9 +338,13 @@ func createIssuesFromGraph(planFile string, dryRun bool, opts GraphApplyOptions)
return HandleErrorRespectJSON("parsing graph plan: %v", err)
}
customTypes, err := resolveWorkspaceCustomTypes(rootCtx)
if err != nil {
return HandleErrorRespectJSON("%v", err)
}
dbPrefix, allowedPrefixes := loadEmbeddedIDPrefixes()
cfg := graphPlanConfig{
customTypes: loadEmbeddedCustomTypes(),
customTypes: customTypes,
customStatuses: loadEmbeddedCustomStatuses(),
dbPrefix: dbPrefix,
allowedPrefixes: allowedPrefixes,

View file

@ -6,7 +6,9 @@ import (
"strings"
"github.com/spf13/cobra"
"github.com/steveyegge/beads/internal/config"
"github.com/steveyegge/beads/internal/metrics"
"github.com/steveyegge/beads/internal/storage/issueops"
"github.com/steveyegge/beads/internal/types"
)
@ -26,14 +28,45 @@ var coreWorkTypes = []struct {
{types.TypeMilestone, "Marks completion of a set of related issues (contains no work itself)"},
}
// systemTypeDescriptions describes the built-in types that are not core work
// types. bd's own commands create them (mail, molecules, gates, set-state), and
// like the core types they validate without any types.custom entry.
var systemTypeDescriptions = map[types.IssueType]string{
types.TypeMessage: "Message between agents or users",
types.TypeMolecule: "Molecule root for swarm coordination (bd mol)",
types.TypeGate: "Async coordination gate (bd gate, formula gates)",
types.TypeEvent: "Audit-trail event (bd set-state)",
}
// systemWorkTypes lists every built-in type that is not a core work type, in
// the types package's declaration order. Together with coreWorkTypes it covers
// exactly the types IssueType.IsBuiltIn accepts.
func systemWorkTypes() []typeInfo {
core := make(map[types.IssueType]bool, len(coreWorkTypes))
for _, t := range coreWorkTypes {
core[t.Type] = true
}
var out []typeInfo
for _, t := range append(append([]types.IssueType{}, types.AllIssueTypes...), types.TypeEvent) {
if core[t] {
continue
}
out = append(out, typeInfo{Name: string(t), Description: systemTypeDescriptions[t]})
}
return out
}
var typesCmd = &cobra.Command{
Use: "types",
GroupID: "views",
Short: "List valid issue types",
Long: `List all valid issue types that can be used with bd create --type.
Core work types (bug, task, feature, chore, epic, decision, spike, story, milestone) are always valid.
Additional types require configuration via types.custom in .beads/config.yaml.
Core work types (bug, task, feature, chore, epic, decision, spike, story, milestone)
and system types (message, molecule, gate, event) are always valid.
Custom types are registered with 'bd config set types.custom' or declared under
types.custom in .beads/config.yaml; the list shown is exactly the set that
bd create --type accepts.
Examples:
bd types # List all types with descriptions
@ -55,32 +88,56 @@ Examples:
return printSections(jsonOutput)
}
if usesProxiedServer() {
return runTypesProxiedServer(rootCtx)
}
if err := ensureDirectMode("types command requires direct database access"); err != nil {
return HandleError("%v", err)
}
var customTypes []string
ctx := context.Background()
if store != nil {
if ct, err := store.GetCustomTypes(ctx); err == nil {
customTypes = ct
if !usesProxiedServer() {
if err := ensureDirectMode("types command requires direct database access"); err != nil {
return HandleError("%v", err)
}
}
customTypes, err := resolveWorkspaceCustomTypes(rootCtx)
if err != nil {
return HandleError("%v", err)
}
return renderTypes(customTypes)
},
}
// resolveWorkspaceCustomTypes returns the workspace's registered custom issue
// types in either storage mode. Both routes end in issueops.ComposeCustomTypes,
// the rule issue create/update validation also resolves through, so what
// `bd types` lists is exactly what `bd create --type` accepts.
func resolveWorkspaceCustomTypes(ctx context.Context) ([]string, error) {
if usesProxiedServer() {
uw, err := openProxiedListUOW(ctx)
if err != nil {
return nil, err
}
defer uw.Close(ctx)
customTypes, err := uw.ConfigUseCase().GetCustomTypes(ctx)
if err != nil {
return nil, fmt.Errorf("reading custom types: %w", err)
}
return customTypes, nil
}
if store == nil {
// No database is open (e.g. a --dry-run plan check): the config.yaml
// layer is the only one available, composed by the same rule.
return issueops.ComposeCustomTypes(nil, "", config.GetCustomTypesFromYAML()), nil
}
customTypes, err := store.GetCustomTypes(ctx)
if err != nil {
return nil, fmt.Errorf("reading custom types: %w", err)
}
return customTypes, nil
}
func renderTypes(customTypes []string) error {
if jsonOutput {
result := struct {
CoreTypes []typeInfo `json:"core_types"`
SystemTypes []typeInfo `json:"system_types"`
CustomTypes []string `json:"custom_types,omitempty"`
}{}
}{SystemTypes: systemWorkTypes()}
for _, t := range coreWorkTypes {
result.CoreTypes = append(result.CoreTypes, typeInfo{
@ -97,6 +154,11 @@ func renderTypes(customTypes []string) error {
fmt.Printf(" %-14s %s\n", t.Type, t.Description)
}
fmt.Println("\nSystem types (built-in, created by bd commands):")
for _, t := range systemWorkTypes() {
fmt.Printf(" %-14s %s\n", t.Name, t.Description)
}
if len(customTypes) > 0 {
fmt.Println("\nConfigured custom types:")
for _, t := range customTypes {

View file

@ -0,0 +1,40 @@
package main
import (
"testing"
"github.com/steveyegge/beads/internal/types"
)
// TestBdTypesListsEveryBuiltIn pins that `bd types` (core + system sections)
// lists exactly the types that validate without configuration, i.e. the set
// IssueType.IsBuiltIn accepts, each with a description.
func TestBdTypesListsEveryBuiltIn(t *testing.T) {
listed := map[types.IssueType]bool{}
for _, ct := range coreWorkTypes {
if listed[ct.Type] {
t.Errorf("core type %q listed twice", ct.Type)
}
listed[ct.Type] = true
}
for _, st := range systemWorkTypes() {
it := types.IssueType(st.Name)
if listed[it] {
t.Errorf("type %q listed as both core and system", it)
}
if st.Description == "" {
t.Errorf("system type %q has no description", it)
}
listed[it] = true
}
for it := range listed {
if !it.IsBuiltIn() {
t.Errorf("bd types lists %q as built-in, but IsBuiltIn rejects it", it)
}
}
for _, it := range append(append([]types.IssueType{}, types.AllIssueTypes...), types.TypeEvent) {
if !listed[it] {
t.Errorf("built-in type %q validates without configuration but bd types does not list it", it)
}
}
}

View file

@ -0,0 +1,130 @@
//go:build cgo
package main
import (
"encoding/json"
"os"
"os/exec"
"path/filepath"
"strings"
"testing"
)
// typesAgreementRunner runs bd in a workspace and returns stdout (or stdout+stderr on
// failure) plus the exit error.
type typesAgreementRunner func(t *testing.T, args ...string) ([]byte, error)
// assertTypesAgreeWithCreate is the `bd types` ⇔ `bd create --type` contract:
// every type `bd types --json` lists is accepted by create and by
// storage-class config validation, and an unlisted type is rejected.
// Custom types are seeded from both sources — the database (bd config set)
// and the project's .beads/config.yaml — because each storage mode resolves
// them; the listing and validation paths must compose them identically.
func assertTypesAgreeWithCreate(t *testing.T, run typesAgreementRunner, beadsDir string) {
t.Helper()
if out, err := run(t, "config", "set", "types.custom", "dbtype"); err != nil {
t.Fatalf("config set types.custom: %v\n%s", err, out)
}
cfgPath := filepath.Join(beadsDir, "config.yaml")
cfg, err := os.ReadFile(cfgPath)
if err != nil {
t.Fatalf("read config.yaml: %v", err)
}
if strings.Contains(string(cfg), "types.custom") || strings.Contains(string(cfg), "\ntypes:") {
t.Fatalf("fixture config.yaml already declares types; test assumes it does not:\n%s", cfg)
}
cfg = append(cfg, []byte("\ntypes.custom: \"yamltype\"\n")...)
if err := os.WriteFile(cfgPath, cfg, 0o644); err != nil {
t.Fatalf("write config.yaml: %v", err)
}
out, err := run(t, "types", "--json")
if err != nil {
t.Fatalf("types --json: %v\n%s", err, out)
}
var listed struct {
CoreTypes []typeInfo `json:"core_types"`
SystemTypes []typeInfo `json:"system_types"`
CustomTypes []string `json:"custom_types"`
}
if err := json.Unmarshal(out, &listed); err != nil {
t.Fatalf("unmarshal types --json: %v\n%s", err, out)
}
names := map[string]bool{}
for _, ti := range append(listed.CoreTypes, listed.SystemTypes...) {
names[ti.Name] = true
}
for _, c := range listed.CustomTypes {
names[c] = true
}
// Types create is known to accept must be listed.
for _, want := range []string{"task", "message", "molecule", "gate", "event", "dbtype", "yamltype"} {
if !names[want] {
t.Errorf("bd types does not list %q, but bd create accepts it; listed=%v", want, names)
}
}
// Every listed type must be accepted by create ...
for name := range names {
if out, err := run(t, "create", "--silent", "--type", name, "agreement "+name); err != nil {
t.Errorf("bd types lists %q but bd create --type %s failed: %v\n%s", name, name, err, out)
}
}
// ... and by storage-class validation, which names issue types too.
for _, name := range listed.CustomTypes {
if out, err := run(t, "config", "set", "storage-class."+name, "versioned"); err != nil {
t.Errorf("bd types lists %q but config set storage-class.%s failed: %v\n%s", name, name, err, out)
}
}
// An unlisted type is rejected.
if out, err := run(t, "create", "--silent", "--type", "notregistered", "agreement unlisted"); err == nil {
t.Errorf("bd create accepted unlisted type notregistered: %s", out)
}
}
func TestProxiedServerTypesAgreeWithCreate(t *testing.T) {
requireSharedProxiedServer(t)
t.Parallel()
bd := buildEmbeddedBD(t)
p := newSharedProxiedProject(t, bd, "tac")
assertTypesAgreeWithCreate(t, func(t *testing.T, args ...string) ([]byte, error) {
return bdProxiedRun(t, bd, p.dir, args...)
}, p.beadsDir)
}
func TestEmbeddedTypesAgreeWithCreate(t *testing.T) {
if os.Getenv("BEADS_TEST_EMBEDDED_DOLT") != "1" {
t.Skip("set BEADS_TEST_EMBEDDED_DOLT=1 to run embedded dolt integration tests")
}
t.Parallel()
bd := buildEmbeddedBD(t)
dir, beadsDir, _ := bdInit(t, bd, "--prefix", "tac")
assertTypesAgreeWithCreate(t, func(t *testing.T, args ...string) ([]byte, error) {
return bdRunWithFlockRetry(t, bd, dir, args...)
}, beadsDir)
}
// Server mode (`bd init --server` against an external dolt sql-server) lists
// through DoltStore.GetCustomTypes, the resolver that used to drop
// config.yaml types once the database had any.
func TestServerModeTypesAgreeWithCreate(t *testing.T) {
requireSharedProxiedServer(t)
t.Parallel()
bd := buildEmbeddedBD(t)
p := newServerModeProject(t, bd, "tas")
assertTypesAgreeWithCreate(t, func(t *testing.T, args ...string) ([]byte, error) {
t.Helper()
cmd := exec.Command(bd, args...)
cmd.Dir = p.dir
cmd.Env = p.env
stdout, stderr, err := runCommandBuffers(t, cmd)
if err != nil {
return append(stdout.Bytes(), stderr.Bytes()...), err
}
return stdout.Bytes(), nil
}, p.beadsDir)
}

View file

@ -1,20 +0,0 @@
package main
import (
"context"
)
func runTypesProxiedServer(ctx context.Context) error {
uw, err := openProxiedListUOW(ctx)
if err != nil {
return HandleError("%v", err)
}
defer uw.Close(ctx)
var customTypes []string
if ct, err := uw.ConfigUseCase().GetCustomTypes(ctx); err == nil {
customTypes = ct
}
return renderTypes(customTypes)
}

View file

@ -126,22 +126,25 @@ func (r *configSQLRepositoryImpl) GetAllConfig(ctx context.Context) (map[string]
return out, nil
}
// GetCustomTypes resolves the workspace's custom issue types through
// issueops.ComposeCustomTypes, the same rule the embedded and server-mode
// stores use, so proxied `bd types` and proxied create/update validation
// accept exactly the same set.
func (r *configSQLRepositoryImpl) GetCustomTypes(ctx context.Context) ([]string, error) {
fromTable, err := r.readCustomTypesTable(ctx)
if err != nil {
return nil, err
}
fromDB := fromTable
if len(fromDB) == 0 {
fromConfig, err := r.readCustomTypesConfig(ctx)
var configValue string
if len(fromTable) == 0 {
configValue, err = r.GetConfig(ctx, "types.custom")
if err != nil {
return nil, err
return nil, fmt.Errorf("db: GetCustomTypes: %w", err)
}
fromDB = fromConfig
}
return unionWithYAMLCustomTypes(fromDB, config.GetCustomTypesFromYAML()), nil
return issueops.ComposeCustomTypes(fromTable, configValue, config.GetCustomTypesFromYAML()), nil
}
func (r *configSQLRepositoryImpl) readCustomTypesTable(ctx context.Context) ([]string, error) {
@ -169,39 +172,6 @@ func (r *configSQLRepositoryImpl) readCustomTypesTable(ctx context.Context) ([]s
return out, nil
}
func (r *configSQLRepositoryImpl) readCustomTypesConfig(ctx context.Context) ([]string, error) {
value, err := r.GetConfig(ctx, "types.custom")
if err != nil {
return nil, fmt.Errorf("db: GetCustomTypes: %w", err)
}
return issueops.ParseTypesConfigValue(value), nil
}
func unionWithYAMLCustomTypes(dbTypes, yamlTypes []string) []string {
if len(dbTypes) == 0 && len(yamlTypes) == 0 {
return nil
}
seen := make(map[string]struct{}, len(dbTypes)+len(yamlTypes))
out := make([]string, 0, len(dbTypes)+len(yamlTypes))
for _, src := range [][]string{dbTypes, yamlTypes} {
for _, t := range src {
t = strings.TrimSpace(t)
if t == "" {
continue
}
if _, ok := seen[t]; ok {
continue
}
seen[t] = struct{}{}
out = append(out, t)
}
}
if len(out) == 0 {
return nil
}
return out
}
func (r *configSQLRepositoryImpl) GetAllowedPrefixes(ctx context.Context) (string, error) {
value, err := r.GetConfig(ctx, "allowed_prefixes")
if err != nil {

View file

@ -132,6 +132,7 @@ go_test(
"create_only_errors_test.go",
"create_only_guard_test.go",
"create_test.go",
"custom_types_parity_test.go",
"cycle_report_test.go",
"cycles_test.go",
"delete_cascade_tables_test.go",

View file

@ -56,7 +56,7 @@ func ResolveCustomConfigInTx(ctx context.Context, tx DBTX) (statuses []types.Cus
return nil, nil, err
}
if statusesFromTable && typesFromTable {
return statuses, customTypes, nil
return statuses, ComposeCustomTypes(customTypes, "", config.GetCustomTypesFromYAML()), nil
}
cfg, err := getConfigKeysInTx(ctx, tx, "status.custom", "types.custom")
@ -66,12 +66,8 @@ func ResolveCustomConfigInTx(ctx context.Context, tx DBTX) (statuses []types.Cus
statuses = ParseStatusFallback(yamlStatuses)
}
}
if !typesFromTable {
if yamlTypes := config.GetCustomTypesFromYAML(); len(yamlTypes) > 0 {
customTypes = yamlTypes
}
}
return statuses, customTypes, nil
// The types.custom row is unreadable; the remaining layers still compose.
return statuses, ComposeCustomTypes(customTypes, "", config.GetCustomTypesFromYAML()), nil
}
if !statusesFromTable {
@ -83,14 +79,7 @@ func ResolveCustomConfigInTx(ctx context.Context, tx DBTX) (statuses []types.Cus
statuses = ParseStatusFallback(yamlStatuses)
}
}
if !typesFromTable {
if v := cfg["types.custom"]; v != "" {
customTypes = ParseTypesConfigValue(v)
} else if yamlTypes := config.GetCustomTypesFromYAML(); len(yamlTypes) > 0 {
customTypes = yamlTypes
}
}
return statuses, customTypes, nil
return statuses, ComposeCustomTypes(customTypes, cfg["types.custom"], config.GetCustomTypesFromYAML()), nil
}
func resolveCustomStatusesFromTableInTx(ctx context.Context, tx DBTX) ([]types.CustomStatus, bool, error) {
@ -280,21 +269,42 @@ func ResolveCustomTypesInTx(ctx context.Context, tx DBTX) ([]string, error) {
// fallback. The table-empty case is intentional: schema migration creates the
// table but may not have populated it from the existing types.custom config
// string yet.
var configValue string
if len(fromDB) == 0 {
value, err := GetConfigInTx(ctx, tx, "types.custom")
if err != nil {
return customTypesYAMLFallback(config.GetCustomTypesFromYAML, err)
}
if value != "" {
fromDB = ParseTypesConfigValue(value)
}
configValue = value
}
return ComposeCustomTypes(fromDB, configValue, config.GetCustomTypesFromYAML()), nil
}
// Overlay-union with YAML types.custom regardless of the DB-side result.
// gastownhall/beads#4024: project-extension types declared in .beads/config.yaml
// must validate server-side even when the database side hasn't been migrated
// or populated with those types.
return mergeWithYAMLCustomTypes(fromDB, config.GetCustomTypesFromYAML), nil
// ComposeCustomTypes is the single rule for which custom issue types a
// workspace has. Every reader of the three sources — the resolvers here, the
// proxied-server config repository, and therefore both `bd types` and
// create/update validation in every mode — composes them through this
// function, so the listed set and the accepted set cannot drift apart:
//
// 1. the custom_types table, when it has rows;
// 2. otherwise the types.custom config row (CSV or JSON array), which covers
// databases whose table has not been populated yet;
// 3. always unioned with config.yaml types.custom, the project-extension
// overlay (gastownhall/beads#4024).
//
// Names are trimmed, empties dropped and duplicates removed; database types
// keep their order and YAML-only types are appended in declared order.
// Returns nil when no layer supplies a type.
func ComposeCustomTypes(fromTable []string, configValue string, yamlTypes []string) []string {
fromDB := dedupePreservingOrder(fromTable)
if len(fromDB) == 0 && configValue != "" {
fromDB = dedupePreservingOrder(ParseTypesConfigValue(configValue))
}
merged := mergeWithYAMLCustomTypes(fromDB, func() []string { return yamlTypes })
if len(merged) == 0 {
return nil
}
return merged
}
// mergeWithYAMLCustomTypes returns the union of dbTypes and the YAML-declared

View file

@ -0,0 +1,173 @@
package issueops
import (
"context"
"os"
"path/filepath"
"reflect"
"regexp"
"testing"
"github.com/DATA-DOG/go-sqlmock"
"github.com/steveyegge/beads/internal/config"
)
// withYAMLCustomTypes points the process config at a throwaway
// .beads/config.yaml declaring types.custom, with HOME and XDG_CONFIG_HOME
// isolated so no user-level config can leak in.
func withYAMLCustomTypes(t *testing.T, customCSV string) {
t.Helper()
dir := t.TempDir()
t.Setenv("HOME", filepath.Join(dir, "home"))
t.Setenv("XDG_CONFIG_HOME", filepath.Join(dir, "xdg"))
t.Setenv("BEADS_DIR", "")
beadsDir := filepath.Join(dir, ".beads")
if err := os.MkdirAll(beadsDir, 0o755); err != nil {
t.Fatalf("mkdir .beads: %v", err)
}
content := ""
if customCSV != "" {
content = "types:\n custom: \"" + customCSV + "\"\n"
}
if err := os.WriteFile(filepath.Join(beadsDir, "config.yaml"), []byte(content), 0o644); err != nil {
t.Fatalf("write config.yaml: %v", err)
}
t.Chdir(dir)
config.ResetForTesting()
if err := config.Initialize(); err != nil {
t.Fatalf("config.Initialize: %v", err)
}
t.Cleanup(config.ResetForTesting)
}
// customTypeSources describes one database + config.yaml state.
type customTypeSources struct {
table []string // custom_types rows
configRow string // config types.custom value ("" = unset)
yaml string // config.yaml types.custom CSV ("" = unset)
}
func expectCustomTypesTable(mock sqlmock.Sqlmock, names []string) {
rows := sqlmock.NewRows([]string{"name"})
for _, n := range names {
rows.AddRow(n)
}
mock.ExpectQuery(regexp.QuoteMeta("SELECT name FROM custom_types ORDER BY name")).WillReturnRows(rows)
}
// resolveViaCustomTypesInTx is the resolver issue create/update validation uses.
func resolveViaCustomTypesInTx(t *testing.T, src customTypeSources) []string {
t.Helper()
db, mock, tx := beginMockTx(t)
defer db.Close()
expectCustomTypesTable(mock, src.table)
if len(src.table) == 0 {
rows := sqlmock.NewRows([]string{"value"})
if src.configRow != "" {
rows.AddRow(src.configRow)
}
mock.ExpectQuery(regexp.QuoteMeta("SELECT value FROM config WHERE `key` = ?")).
WithArgs("types.custom").WillReturnRows(rows)
}
got, err := ResolveCustomTypesInTx(context.Background(), tx)
if err != nil {
t.Fatalf("ResolveCustomTypesInTx: %v", err)
}
if err := mock.ExpectationsWereMet(); err != nil {
t.Fatalf("unmet SQL expectations: %v", err)
}
return got
}
// resolveViaCustomConfigInTx is the resolver the server-mode store's
// GetCustomTypes (and so direct-mode `bd types`) uses.
func resolveViaCustomConfigInTx(t *testing.T, src customTypeSources) []string {
t.Helper()
db, mock, tx := beginMockTx(t)
defer db.Close()
// One custom status so the status half resolves from its table and the
// config-row read below is driven by the types half alone.
mock.ExpectQuery(regexp.QuoteMeta("SELECT name, category FROM custom_statuses ORDER BY name")).
WillReturnRows(sqlmock.NewRows([]string{"name", "category"}).AddRow("review", "wip"))
expectCustomTypesTable(mock, src.table)
if len(src.table) == 0 {
rows := sqlmock.NewRows([]string{"key", "value"})
if src.configRow != "" {
rows.AddRow("types.custom", src.configRow)
}
mock.ExpectQuery(regexp.QuoteMeta("SELECT `key`, value FROM config WHERE `key` IN (?,?)")).
WithArgs("status.custom", "types.custom").WillReturnRows(rows)
}
_, got, err := ResolveCustomConfigInTx(context.Background(), tx)
if err != nil {
t.Fatalf("ResolveCustomConfigInTx: %v", err)
}
if err := mock.ExpectationsWereMet(); err != nil {
t.Fatalf("unmet SQL expectations: %v", err)
}
return got
}
// TestCustomTypeResolversAgree pins the single composition rule for custom
// issue types (custom_types table, else the types.custom config row, always
// unioned with config.yaml types.custom). The listing path (`bd types`) and
// the validation path (create/update) must resolve the same set, or `bd types`
// advertises types that create rejects or vice versa.
func TestCustomTypeResolversAgree(t *testing.T) {
cases := []struct {
name string
src customTypeSources
want []string
}{
{"nothing configured", customTypeSources{}, nil},
{"table only", customTypeSources{table: []string{"convoy", "rig"}}, []string{"convoy", "rig"}},
{"config row only", customTypeSources{configRow: "convoy,rig"}, []string{"convoy", "rig"}},
{"yaml only", customTypeSources{yaml: "gizmo"}, []string{"gizmo"}},
{"table plus yaml", customTypeSources{table: []string{"convoy"}, yaml: "gizmo"}, []string{"convoy", "gizmo"}},
{"config row plus yaml", customTypeSources{configRow: "convoy", yaml: "gizmo,convoy"}, []string{"convoy", "gizmo"}},
{"table wins over config row", customTypeSources{table: []string{"convoy"}, configRow: "convoy,rig", yaml: "gizmo"}, []string{"convoy", "gizmo"}},
}
for _, tc := range cases {
t.Run(tc.name, func(t *testing.T) {
withYAMLCustomTypes(t, tc.src.yaml)
validate := resolveViaCustomTypesInTx(t, tc.src)
list := resolveViaCustomConfigInTx(t, tc.src)
if len(validate) == 0 && len(tc.want) == 0 && len(list) == 0 {
return
}
if !reflect.DeepEqual(validate, tc.want) {
t.Errorf("ResolveCustomTypesInTx = %#v, want %#v", validate, tc.want)
}
if !reflect.DeepEqual(list, tc.want) {
t.Errorf("ResolveCustomConfigInTx custom types = %#v, want %#v (must match the validation resolver)", list, tc.want)
}
})
}
}
func TestComposeCustomTypes(t *testing.T) {
cases := []struct {
name string
table []string
configRow string
yaml []string
want []string
}{
{"empty", nil, "", nil, nil},
{"table trimmed and deduped", []string{" convoy ", "", "convoy", "rig"}, "", nil, []string{"convoy", "rig"}},
{"config row json form", nil, `["convoy","rig"]`, nil, []string{"convoy", "rig"}},
{"table ignores config row", []string{"convoy"}, "rig", nil, []string{"convoy"}},
{"yaml appended after db", []string{"rig"}, "", []string{"gizmo", "rig"}, []string{"rig", "gizmo"}},
}
for _, tc := range cases {
t.Run(tc.name, func(t *testing.T) {
got := ComposeCustomTypes(tc.table, tc.configRow, tc.yaml)
if len(got) == 0 && len(tc.want) == 0 {
return
}
if !reflect.DeepEqual(got, tc.want) {
t.Errorf("ComposeCustomTypes = %#v, want %#v", got, tc.want)
}
})
}
}