fix(cook/pour): honor declared formula step types instead of squashing them to task (#5520)

* Stop cook coercing non-whitelisted formula step types to task

stepTypeToIssueType had a hardcoded five-type switch whose default
branch silently turned every other step type — custom types like
"duty", but also built-ins like decision, spike, and story — into
task. Pass the type through with Normalize() instead, defaulting to
task only when the step type is empty.

No validation is added here: pour already registers non-built-in
types via ensureSubgraphCustomTypes and the storage layer validates
against types.custom, the same division of labor as bd create --type.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01YLWg73gpPfwinj1jn3UhmU

* Fix custom-type registration gaps and honor declared parent step types

Review follow-ups to the cook/pour type passthrough (GH#5443):

- bd cook --persist now registers custom step types via
  ensureSubgraphCustomTypes, matching the pour path
- doltTransaction.SetConfig syncs custom_types/custom_statuses tables so
  in-transaction registration is visible to validation
- Wisp creation builds its validation BatchContext on regularTx (new
  issueops.CreateIssuesInTxWithContext), so a custom type registered in
  the same transaction validates on the dolt server backend
- Parent steps with a declared type keep it; only an undeclared type
  defaults to epic
- Step types are trimmed before normalizing; types.custom is serialized
  with json.Marshal; doctor's multirepo checks parse it JSON-first
- Registration gates on IsBuiltIn() so built-in types like event are not
  churned into types.custom
- Regression test runs against a local dolt sql-server when the Docker
  test container is unavailable

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01YLWg73gpPfwinj1jn3UhmU

* Consolidate duplicated custom-type plumbing behind shared issueops helpers

Cleanup pass over the GH#5443 branch:

- Export issueops.ParseTypesConfigValue and point the doctor, domain/db,
  template.go's comma-split hack, and config_helpers.go's own inline
  copies at it instead of five parallel JSON-or-CSV parsers.
- Extract issueops.SyncConfigTables to own the config-key -> normalized
  table mapping; all four SetConfig implementations now share it.
- Build one BatchContext per doltTransaction create call: hoisted above
  the wisp/regular branch in CreateIssue, shared across both legs in
  CreateIssues (drops 4 redundant config reads on mixed batches).
- CreateIssuesInTxWithContext sets SkipChildCounterReconcile on a
  shallow copy so the caller's context is reusable.
- Retype ensureSubgraphCustomTypes as ensureCustomTypesForIssues taking
  []*types.Issue, removing cook's throwaway TemplateSubgraph wrapper.
- Rebuild setupLocalServerStore on the setupWispCascadeStore recipe:
  t.Cleanup teardown and CreateIfMissing instead of hand-rolled
  CREATE DATABASE / initSchemaOnDB / shelled dolt init.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01YLWg73gpPfwinj1jn3UhmU

* Stop auto-registering formula custom types; flatten unregistered to task/epic

Pour and cook --persist no longer write step types into types.custom.
A step type that is neither built-in nor already registered is flattened
with a warning — to epic when the step has children (matching the
undeclared-parent default), task otherwise. Operators opt in with
bd config set types.custom before pouring; a typo'd step type can no
longer become a permanently registered custom type.

ensureCustomTypesForIssues (the read-merge-write into types.custom)
becomes flattenUnregisteredIssueTypes, reading types.custom through the
transaction plus config.yaml-declared types to match insert validation.
The now-unused molConfigWriter interface is gone.

Also lands the code-review fixes on the same plumbing:
- storeMolWriter.GetConfig routes through the bound transaction, fixing
  out-of-tx config reads (lost-update window; MaxOpenConns=1 hang).
- doltTransaction.SetConfig invalidates DoltStore's config caches via
  the shared invalidateConfigCaches, so long-lived processes stop
  serving stale custom type/status sets.
- doctor's unknown-type check uses IsBuiltIn instead of a stale 6-type
  hardcoded list that would have flagged spike/story/gate as unknown.
- schema backfill uses issueops.ParseTypesConfigValue (no import cycle;
  the old copy kept untrimmed JSON elements).
- Dead EnsureCustomTypeInTx (misleading GH#3213 doc, wrote table-only
  rows the sync invariant wipes) and dead GetCustomTypesTx deleted.

Step.Type docs updated and schema_gen.go regenerated via go generate.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01YLWg73gpPfwinj1jn3UhmU

* Fold the last SetConfig path into SyncConfigTables; cleanups

Follow-up cleanup on the custom-types work.

EmbeddedDoltStore.SetConfig still carried the hand-rolled `switch key`
that the other four SetConfig paths replaced with SyncConfigTables, so
the helper's stated invariant — every SetConfig path keeps the
projection in step — had a hole. Route it through the helper, then
unexport syncCustomTypesTable/syncCustomStatusesTable: with no callers
left outside SyncConfigTables, the single-entry-point rule is enforced
by the compiler rather than by a comment.

Smaller cleanups alongside it:

- Drop linearConfigReader; it was the same single-method interface as
  configReader, in the same package.
- flattenUnregisteredIssueTypes built three collections where one does
  the job. Seed `unknown` directly and delete registered types, losing
  the string/IssueType round-trip.
- Use WarnError instead of open-coding its Fprintf.
- processStepToIssue trimmed step.Type twice, once inside
  stepTypeToIssueType and again for the epic default; hoist to one
  declaredType so the two can't drift.
- Remove the `typesStr == ""` guard in readTypesFromDB, left behind
  when its loop became ParseTypesConfigValue (which returns nil for
  empty).
- Rename the BatchContext copy in CreateIssuesInTxWithContext from
  `local` to `batch` instead of reassigning the parameter, so bc
  provably stays the caller's pointer.
- Lead storeMolWriter.GetConfig's doc with the reason that still
  applies (second pool connection deadlocks at MaxOpenConns=1); nothing
  registers types in-transaction during pour any more.

No behavior change. gofmt, go vet, and the affected tests pass;
golangci-lint was not available locally.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01YLWg73gpPfwinj1jn3UhmU

---------

Co-authored-by: Claude Fable 5 <noreply@anthropic.com>
This commit is contained in:
Isis Anisoptera 2026-08-10 05:36:33 -07:00 • committed by GitHub
commit ef0ec061fa
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
20 changed files with 493 additions and 296 deletions

View file

@ -16,22 +16,18 @@ import (
)
// stepTypeToIssueType converts a formula step type string to a types.IssueType.
// Returns types.TypeTask for empty or unrecognized types.
// Returns types.TypeTask for empty types. Non-empty types pass through
// (trimmed and normalized) rather than being validated here: at pour and
// cook --persist time, flattenUnregisteredIssueTypes degrades types that
// are neither built-in nor registered in types.custom to task (with a
// warning), and the storage layer validates what remains — the same
// division of labor as bd create --type.
func stepTypeToIssueType(stepType string) types.IssueType {
switch stepType {
case "task":
return types.TypeTask
case "bug":
return types.TypeBug
case "feature":
return types.TypeFeature
case "epic":
return types.TypeEpic
case "chore":
return types.TypeChore
default:
stepType = strings.TrimSpace(stepType)
if stepType == "" {
return types.TypeTask
}
return types.IssueType(stepType).Normalize()
}
// cookCmd compiles a formula JSON into a proto bead.
@ -561,9 +557,12 @@ func processStepToIssue(step *formula.Step, parentID string) *types.Issue {
// Generate issue ID (formula-name.step-id)
issueID := fmt.Sprintf("%s.%s", parentID, step.ID)
// Determine issue type (children override to epic)
issueType := stepTypeToIssueType(step.Type)
if len(step.Children) > 0 {
// Determine issue type. A parent step with no declared type defaults to
// epic; a declared type is honored even when the step has children
// (GH#5443).
declaredType := strings.TrimSpace(step.Type)
issueType := stepTypeToIssueType(declaredType)
if len(step.Children) > 0 && declaredType == "" {
issueType = types.TypeEpic
}
@ -901,6 +900,14 @@ func cookFormula(ctx context.Context, s storage.DoltStorage, f *formula.Formula,
// Create issues, labels, and dependencies in a single atomic transaction.
// This prevents orphaned issues if label/dependency creation fails.
err := transact(ctx, s, fmt.Sprintf("bd: cook formula %s", protoID), func(tx storage.Transaction) error {
// Flatten unregistered step types to task (with a warning) before
// inserting, mirroring cloneSubgraphInto (pour). Without this,
// PrepareIssueForInsert rejects them with "invalid issue type" and
// the whole cook --persist transaction rolls back.
if err := flattenUnregisteredIssueTypes(ctx, storeMolWriter{DoltStorage: s, tx: tx}, issues, deps); err != nil {
return fmt.Errorf("checking custom types: %w", err)
}
// Create all issues
if err := tx.CreateIssues(ctx, issues, actor); err != nil {
return fmt.Errorf("failed to create issues: %w", err)

View file

@ -974,3 +974,66 @@ func TestCookFormulaToSubgraph_StepMetadata(t *testing.T) {
t.Errorf("Metadata[origin] = %v, want \"repro\"", got)
}
}
// TestProcessStepToIssueParentType verifies that a parent step's declared
// type is honored; only a step with children and no declared type defaults
// to epic (GH#5443).
func TestProcessStepToIssueParentType(t *testing.T) {
tests := []struct {
name string
stepType string
want types.IssueType
}{
{"undeclared parent defaults to epic", "", types.TypeEpic},
{"declared built-in type kept on parent", "decision", types.TypeDecision},
{"declared custom type kept on parent", "duty", types.IssueType("duty")},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
step := &formula.Step{
ID: "parent",
Title: "parent step",
Type: tt.stepType,
Children: []*formula.Step{{ID: "c", Title: "child step"}},
}
issue := processStepToIssue(step, "f")
if issue.IssueType != tt.want {
t.Errorf("IssueType = %q, want %q", issue.IssueType, tt.want)
}
})
}
}
func TestStepTypeToIssueType(t *testing.T) {
tests := []struct {
stepType string
want types.IssueType
}{
// Core work types pass through.
{"task", types.TypeTask},
{"bug", types.TypeBug},
{"feature", types.TypeFeature},
{"epic", types.TypeEpic},
{"chore", types.TypeChore},
// Empty (or whitespace-only) defaults to task; surrounding
// whitespace is trimmed rather than becoming part of the type.
{"", types.TypeTask},
{" ", types.TypeTask},
{" bug ", types.TypeBug},
// Other built-in types pass through instead of collapsing to task.
{"decision", types.TypeDecision},
{"spike", types.TypeSpike},
{"story", types.TypeStory},
// Aliases normalize to their canonical form.
{"enhancement", types.TypeFeature},
// Non-built-in types pass through; at pour/cook time,
// flattenUnregisteredIssueTypes degrades them to task unless they
// are already registered in types.custom.
{"duty", types.IssueType("duty")},
}
for _, tt := range tests {
if got := stepTypeToIssueType(tt.stepType); got != tt.want {
t.Errorf("stepTypeToIssueType(%q) = %q, want %q", tt.stepType, got, tt.want)
}
}
}

View file

@ -12,6 +12,8 @@ import (
"github.com/steveyegge/beads/internal/config"
"github.com/steveyegge/beads/internal/configfile"
"github.com/steveyegge/beads/internal/storage/dolt"
"github.com/steveyegge/beads/internal/storage/issueops"
"github.com/steveyegge/beads/internal/types"
)
// multiRepoYAMLConfig represents the types section of config.yaml for YAML unmarshaling.
@ -129,20 +131,8 @@ func readTypesFromDB(beadsDir string) ([]string, error) {
return nil, err
}
if typesStr == "" {
return nil, nil
}
// Parse comma-separated list
var types []string
for _, t := range strings.Split(typesStr, ",") {
t = strings.TrimSpace(t)
if t != "" {
types = append(types, t)
}
}
return types, nil
// ParseTypesConfigValue returns nil for an empty or whitespace-only value.
return issueops.ParseTypesConfigValue(typesStr), nil
}
// readTypesFromYAML reads types.custom from config.yaml
@ -189,20 +179,17 @@ func findUnknownTypesInHydratedIssues(repoPath string, multiRepo *config.MultiRe
}
defer func() { _ = store.Close() }()
// Collect all known types (core work types + parent custom + all child custom)
// Only core work types are built-in; orchestrator types require types.custom config.
knownTypes := map[string]bool{
"bug": true, "feature": true, "task": true, "epic": true, "chore": true, "decision": true,
}
// Collect known custom types (parent custom + all child custom).
// Built-in types — including orchestrator types like gate, molecule,
// spike, story, and milestone — are recognized via IsBuiltIn below, so
// this map only needs the configured custom types.
knownTypes := make(map[string]bool)
// Add parent's custom types
parentTypes, err := store.GetConfig(ctx, "types.custom")
if err == nil && parentTypes != "" {
for _, t := range strings.Split(parentTypes, ",") {
t = strings.TrimSpace(t)
if t != "" {
knownTypes[t] = true
}
for _, t := range issueops.ParseTypesConfigValue(parentTypes) {
knownTypes[t] = true
}
}
@ -232,7 +219,7 @@ func findUnknownTypesInHydratedIssues(repoPath string, multiRepo *config.MultiRe
if err := rows.Scan(&issueType); err != nil {
continue
}
if !knownTypes[issueType] && !seen[issueType] {
if !types.IssueType(issueType).IsBuiltIn() && !knownTypes[issueType] && !seen[issueType] {
unknownTypes = append(unknownTypes, issueType)
seen[issueType] = true
}

View file

@ -1217,13 +1217,6 @@ func getLinearIDMode(ctx context.Context) string {
return mode
}
// linearConfigReader is the minimal slice of storage.Storage that the
// linear-config helpers depend on. Lets tests inject a fake without
// spinning up a Dolt server.
type linearConfigReader interface {
GetConfig(ctx context.Context, key string) (string, error)
}
// applyLinearExcludeIDConfig reads linear.exclude_id_prefix and
// linear.exclude_id_patterns from the given config reader and applies them
// to opts. Both keys are push-direction-only filters; see the help text on
@ -1231,7 +1224,7 @@ type linearConfigReader interface {
//
// Empty values are no-ops. Patterns are comma-split, trimmed, with empty
// entries dropped. If reader is nil (no store configured), this is a no-op.
func applyLinearExcludeIDConfig(ctx context.Context, reader linearConfigReader, opts *tracker.SyncOptions) {
func applyLinearExcludeIDConfig(ctx context.Context, reader configReader, opts *tracker.SyncOptions) {
if reader == nil || opts == nil {
return
}

View file

@ -1771,7 +1771,7 @@ func TestIsValidUUID(t *testing.T) {
}
}
// fakeLinearConfigReader is a test double for linearConfigReader that
// fakeLinearConfigReader is a test double for configReader that
// returns values from an in-memory map. Unset keys return "" with no error
// (matches storage.Storage's behavior for missing config keys).
type fakeLinearConfigReader map[string]string

View file

@ -38,13 +38,6 @@ type molReader interface {
var _ molReader = storage.DoltStorage(nil)
type molConfigWriter interface {
molReader
SetConfig(ctx context.Context, key, value string) error
}
var _ molConfigWriter = storage.DoltStorage(nil)
type molWriter interface {
molReader
CreateIssue(ctx context.Context, issue *types.Issue, actor string) error
@ -90,6 +83,19 @@ func (w storeMolWriter) SetConfig(ctx context.Context, key, value string) error
return w.tx.SetConfig(ctx, key, value)
}
// GetConfig reads through the transaction when one is bound. Without this,
// config readers (flattenUnregisteredIssueTypes) would go to the embedded
// store, which opens a second pool connection — a deadlock when
// MaxOpenConns=1 and the transaction already holds the only one. It also
// keeps the read consistent with any config written earlier in the same
// transaction rather than seeing the last committed value.
func (w storeMolWriter) GetConfig(ctx context.Context, key string) (string, error) {
if w.tx != nil {
return w.tx.GetConfig(ctx, key)
}
return w.DoltStorage.GetConfig(ctx, key)
}
func (w storeMolWriter) ClaimStepIfOpen(ctx context.Context, id, actor string) error {
return w.DoltStorage.RunInTransaction(ctx, fmt.Sprintf("bd: advance to step %s", id), func(tx storage.Transaction) error {
current, err := tx.GetIssue(ctx, id)

View file

@ -6,15 +6,26 @@ import (
"encoding/json"
"fmt"
"regexp"
"sort"
"strings"
"time"
"github.com/steveyegge/beads/internal/config"
"github.com/steveyegge/beads/internal/formula"
"github.com/steveyegge/beads/internal/storage"
"github.com/steveyegge/beads/internal/storage/issueops"
"github.com/steveyegge/beads/internal/types"
"github.com/steveyegge/beads/internal/utils"
)
// configReader is the minimal slice of storage.Storage that config-reading
// helpers depend on, letting tests inject a fake without spinning up a Dolt
// server. Transaction-bound writers (storeMolWriter) satisfy it with reads
// that see in-transaction config writes.
type configReader interface {
GetConfig(ctx context.Context, key string) (string, error)
}
// BeadsTemplateLabel is the label used to identify Beads-based templates
const BeadsTemplateLabel = "template"
@ -558,75 +569,78 @@ func getRelativeID(oldID, rootID string) string {
return ""
}
// ensureSubgraphCustomTypes scans the template subgraph for issue types
// that are not built-in and ensures they are registered as custom types
// in the database. This is needed because formula cooking can produce
// issues with types like "gate" (for async coordination beads) that are
// not in the default type whitelist. Without this, cloneSubgraph fails
// with "invalid issue type" on the first non-built-in bead. (GH#3213)
func ensureSubgraphCustomTypes(ctx context.Context, s molConfigWriter, subgraph *TemplateSubgraph) error {
// Collect non-built-in types used by the subgraph.
needed := make(map[string]bool)
for _, issue := range subgraph.Issues {
// flattenUnregisteredIssueTypes flattens issue types that are neither
// built-in nor already registered in types.custom, printing a warning
// naming each flattened type. Issues with children (the DependsOnID side
// of a parent-child dep) flatten to epic — matching the default for
// undeclared parent step types — and leaves flatten to task.
// Materializing a formula must not silently grow the type whitelist — a
// typo'd step type would become a permanently registered custom type — so
// unregistered types degrade instead; operators opt in with bd config set
// types.custom before pouring. Without the flatten, issue creation fails
// with "invalid issue type" on the first unregistered bead.
// (GH#3213, GH#5443)
func flattenUnregisteredIssueTypes(ctx context.Context, s configReader, issues []*types.Issue, deps []*types.Dependency) error {
// Seed with every non-built-in type used by the issues, then remove the
// registered ones below; what survives is unknown. IsBuiltIn (not
// IsValid) matches the validator this check exists to satisfy:
// IsValidWithCustom short-circuits on IsBuiltIn, so types like "event"
// need no types.custom entry.
unknown := make(map[types.IssueType]bool)
for _, issue := range issues {
t := issue.IssueType
if t == "" || t.IsValid() {
if t == "" || t.IsBuiltIn() {
continue
}
needed[string(t)] = true
unknown[t] = true
}
if len(needed) == 0 {
if len(unknown) == 0 {
return nil
}
// Read the current custom types and check which are missing.
// Match insert validation's sources: the types.custom config value
// (kept in step with the custom_types table by SyncConfigTables)
// overlaid with config.yaml-declared types. Read through s so a
// transaction-bound caller sees in-transaction registration.
existing, err := s.GetConfig(ctx, "types.custom")
if err != nil {
existing = ""
// Don't degrade to "nothing registered": a transient read failure
// would silently flatten types the operator did register.
return fmt.Errorf("reading types.custom: %w", err)
}
var current []string
if existing != "" {
// parseTypesValue handles both JSON arrays and comma-separated.
// It's in issueops — but we don't import that package here, so
// do a simple comma split (good enough for the merge check).
for _, t := range strings.Split(strings.Trim(existing, "[] \""), ",") {
t = strings.Trim(t, " \"")
if t != "" {
current = append(current, t)
for _, t := range issueops.ParseTypesConfigValue(existing) {
delete(unknown, types.IssueType(t))
}
for _, t := range config.GetCustomTypesFromYAML() {
delete(unknown, types.IssueType(t))
}
if len(unknown) == 0 {
return nil
}
names := make([]string, 0, len(unknown))
for t := range unknown {
names = append(names, string(t))
}
sort.Strings(names)
WarnError("flattening unregistered issue type(s) to task (epic for steps with children): %s (register with bd config set types.custom to keep them)", strings.Join(names, ", "))
hasChildren := make(map[string]bool)
for _, dep := range deps {
if dep.Type == types.DepParentChild {
hasChildren[dep.DependsOnID] = true
}
}
for _, issue := range issues {
if unknown[issue.IssueType] {
if hasChildren[issue.ID] {
issue.IssueType = types.TypeEpic
} else {
issue.IssueType = types.TypeTask
}
}
}
currentSet := make(map[string]bool, len(current))
for _, t := range current {
currentSet[t] = true
}
var toAdd []string
for t := range needed {
if !currentSet[t] {
toAdd = append(toAdd, t)
}
}
if len(toAdd) == 0 {
return nil
}
// Merge and write back. SetConfig triggers SyncCustomTypesTable
// which populates the normalized custom_types table used by
// PrepareIssueForInsert → ValidateWithCustom.
merged := append(current, toAdd...)
// Serialize as JSON array for consistency with bd config set.
var buf strings.Builder
buf.WriteString("[")
for i, t := range merged {
if i > 0 {
buf.WriteString(",")
}
buf.WriteString("\"")
buf.WriteString(t)
buf.WriteString("\"")
}
buf.WriteString("]")
return s.SetConfig(ctx, "types.custom", buf.String())
return nil
}
// cloneSubgraph creates new issues from the template with variable substitution.
@ -652,8 +666,8 @@ func cloneSubgraph(ctx context.Context, s storage.DoltStorage, subgraph *Templat
}
func cloneSubgraphInto(ctx context.Context, w molWriter, subgraph *TemplateSubgraph, opts CloneOptions) (*InstantiateResult, error) {
if err := ensureSubgraphCustomTypes(ctx, w, subgraph); err != nil {
return nil, fmt.Errorf("registering custom types for subgraph: %w", err)
if err := flattenUnregisteredIssueTypes(ctx, w, subgraph.Issues, subgraph.Dependencies); err != nil {
return nil, fmt.Errorf("checking custom types for subgraph: %w", err)
}
idMapping := make(map[string]string)

View file

@ -1125,3 +1125,48 @@ func TestExtractRequiredVariables_IgnoresUndeclaredVars(t *testing.T) {
})
}
}
// stubConfigReader serves config values from a map for
// flattenUnregisteredIssueTypes tests.
type stubConfigReader map[string]string
func (s stubConfigReader) GetConfig(_ context.Context, key string) (string, error) {
return s[key], nil
}
// TestFlattenUnregisteredIssueTypes verifies that pour/cook honor built-in
// and already-registered custom types but never auto-register: an
// unregistered type degrades (with a warning) instead of silently growing
// types.custom — to epic when the issue has children, task otherwise.
func TestFlattenUnregisteredIssueTypes(t *testing.T) {
cfg := stubConfigReader{"types.custom": `["duty"]`}
issues := []*types.Issue{
{ID: "f.a", IssueType: types.TypeBug},
{ID: "f.b", IssueType: types.IssueType("gate")}, // built-in orchestrator type
{ID: "f.c", IssueType: types.IssueType("duty")}, // registered custom type
{ID: "f.d", IssueType: types.IssueType("typo")}, // unregistered leaf — flattens to task
{ID: "f.e", IssueType: ""},
{ID: "f.p", IssueType: types.IssueType("typo")}, // unregistered parent — flattens to epic
}
deps := []*types.Dependency{
{IssueID: "f.d", DependsOnID: "f.p", Type: types.DepParentChild},
}
if err := flattenUnregisteredIssueTypes(context.Background(), cfg, issues, deps); err != nil {
t.Fatalf("flattenUnregisteredIssueTypes: %v", err)
}
want := []types.IssueType{
types.TypeBug,
types.IssueType("gate"),
types.IssueType("duty"),
types.TypeTask,
"",
types.TypeEpic,
}
for i, issue := range issues {
if issue.IssueType != want[i] {
t.Errorf("issues[%d] (%s) IssueType = %q, want %q", i, issue.ID, issue.IssueType, want[i])
}
}
}

View file

@ -660,7 +660,11 @@ Used for dependency references and bond points.`,
Name: "Type",
Type: "string",
JSONName: "type",
Doc: `Type is the issue type: task, bug, feature, epic, chore.`,
Doc: `Type is the issue type: any built-in type (task by default; bug,
feature, epic, chore, decision, spike, story, milestone, ...) or a
custom type already registered in types.custom. Unregistered types
are flattened to task, with a warning, when the formula is cooked
or poured.`,
},
{
Name: "Priority",

View file

@ -206,7 +206,11 @@ type Step struct {
// Notes are additional notes for the issue (supports substitution).
Notes string `json:"notes,omitempty"`
// Type is the issue type: task, bug, feature, epic, chore.
// Type is the issue type: any built-in type (task by default; bug,
// feature, epic, chore, decision, spike, story, milestone, ...) or a
// custom type already registered in types.custom. Unregistered types
// are flattened to task, with a warning, when the formula is cooked
// or poured.
Type string `json:"type,omitempty"`
// Priority is the issue priority (0-4).

View file

@ -3,7 +3,6 @@ package dolt
import (
"context"
"database/sql"
"fmt"
"log"
"github.com/steveyegge/beads/internal/config"
@ -19,22 +18,26 @@ func (s *DoltStore) SetConfig(ctx context.Context, key, value string) error {
return err
}
// Sync normalized tables when config keys change
switch key {
case "status.custom":
if err := issueops.SyncCustomStatusesTable(ctx, tx, value); err != nil {
return fmt.Errorf("syncing custom_statuses table: %w", err)
}
case "types.custom":
if err := issueops.SyncCustomTypesTable(ctx, tx, value); err != nil {
return fmt.Errorf("syncing custom_types table: %w", err)
}
}
return nil
_, err := issueops.SyncConfigTables(ctx, tx, key, value)
return err
}); err != nil {
return err
}
// Invalidate caches for keys that affect cached data
s.invalidateConfigCaches(key)
return nil
}
// invalidateConfigCaches drops the store-level caches derived from a config
// key. Every path that writes config — store-level SetConfig and
// doltTransaction.SetConfig alike — must call this, or a long-lived process
// (server/daemon) keeps serving the pre-write set from GetCustomTypes /
// GetCustomStatuses / GetInfraTypes until restart. Invalidating for a
// transaction that later rolls back is harmless: the lazy reload just
// re-reads the committed state.
func (s *DoltStore) invalidateConfigCaches(key string) {
s.cacheMu.Lock()
switch key {
case "status.custom":
@ -49,8 +52,6 @@ func (s *DoltStore) SetConfig(ctx context.Context, key, value string) error {
s.infraTypeCache = nil
}
s.cacheMu.Unlock()
return nil
}
// GetConfig retrieves a configuration value

View file

@ -428,19 +428,22 @@ func (t *doltTransaction) CreateIssue(ctx context.Context, issue *types.Issue, a
return fmt.Errorf("issue must not be nil")
}
if issueops.IsWisp(issue) {
bc, err := issueops.NewBatchContext(ctx, t.ignoredTx, storage.BatchCreateOptions{SkipPrefixValidation: true})
if err != nil {
return err
}
_, err = issueops.CreateIssueInTxWithResult(ctx, t.ignoredTx, bc, issue, actor)
return err
}
// Build the validation context on regularTx for both tiers: wisp rows
// live on the ignored session, but the validation context (config,
// custom_types) lives in regular dolt-tracked tables — reading it
// through regularTx keeps types registered earlier in this transaction
// (tx.SetConfig("types.custom", ...)) visible. Both sessions are
// pinned to the same branch (GH#5443).
bc, err := issueops.NewBatchContext(ctx, t.regularTx, storage.BatchCreateOptions{SkipPrefixValidation: true})
if err != nil {
return err
}
if issueops.IsWisp(issue) {
_, err = issueops.CreateIssueInTxWithResult(ctx, t.ignoredTx, bc, issue, actor)
return err
}
result, err := issueops.CreateIssueInTxWithResult(ctx, t.regularTx, bc, issue, actor)
if err != nil {
return err
@ -473,10 +476,18 @@ func (t *doltTransaction) CreateIssues(ctx context.Context, issues []*types.Issu
}
}
// See CreateIssue: one validation context on regularTx serves both
// tiers, so in-transaction custom-type registration is visible to the
// wisp tier too (GH#5443).
bc, err := issueops.NewBatchContext(ctx, t.regularTx, storage.BatchCreateOptions{
SkipPrefixValidation: true,
})
if err != nil {
return err
}
if len(regularIssues) > 0 {
result, err := issueops.CreateIssuesInTxWithResult(ctx, t.regularTx, regularIssues, actor, storage.BatchCreateOptions{
SkipPrefixValidation: true,
})
result, err := issueops.CreateIssuesInTxWithContext(ctx, t.regularTx, bc, regularIssues, actor)
if err != nil {
return err
}
@ -486,9 +497,7 @@ func (t *doltTransaction) CreateIssues(ctx context.Context, issues []*types.Issu
}
if len(wispIssues) > 0 {
if _, err := issueops.CreateIssuesInTxWithResult(ctx, t.ignoredTx, wispIssues, actor, storage.BatchCreateOptions{
SkipPrefixValidation: true,
}); err != nil {
if _, err := issueops.CreateIssuesInTxWithContext(ctx, t.ignoredTx, bc, wispIssues, actor); err != nil {
return err
}
}
@ -1278,10 +1287,28 @@ func (t *doltTransaction) SetConfig(ctx context.Context, key, value string) erro
INSERT INTO config (`+"`key`"+`, value) VALUES (?, ?)
ON DUPLICATE KEY UPDATE value = VALUES(value)
`, key, value)
if err == nil {
t.dirty.MarkDirty("config")
if err != nil {
return wrapExecError("set config in tx", err)
}
return wrapExecError("set config in tx", err)
t.dirty.MarkDirty("config")
// ResolveCustomTypesInTx reads the normalized tables first, so without
// this sync a type registered in-transaction stays invisible to
// validation whenever the table already has rows.
table, err := issueops.SyncConfigTables(ctx, t.regularTx, key, value)
if err != nil {
return err
}
if table != "" {
t.dirty.MarkDirty(table)
}
// Keep store-level caches (GetCustomTypes and friends) coherent with
// in-transaction config writes; see invalidateConfigCaches.
if t.store != nil {
t.store.invalidateConfigCaches(key)
}
return nil
}
// GetConfig gets a config value within the transaction

View file

@ -0,0 +1,124 @@
package dolt
import (
"os"
"path/filepath"
"testing"
"github.com/steveyegge/beads/internal/doltserver"
"github.com/steveyegge/beads/internal/storage"
"github.com/steveyegge/beads/internal/testutil"
"github.com/steveyegge/beads/internal/types"
)
// setupAnyServerStore returns a store on the shared test server when TestMain
// brought one up (Docker), and otherwise starts a private local dolt
// sql-server from the dolt binary — the same recipe as setupWispCascadeStore
// — so the test still runs on machines without a container runtime.
func setupAnyServerStore(t *testing.T) (*DoltStore, func()) {
t.Helper()
if testServerPort != 0 {
return setupTestStore(t)
}
return setupLocalServerStore(t)
}
// setupLocalServerStore starts a dedicated dolt sql-server in a temp dir and
// opens a DoltStore against it. Not parallel: it mutates process env via
// t.Setenv, which is only safe here because every shared-server test skips
// when this path is taken (no container).
func setupLocalServerStore(t *testing.T) (*DoltStore, func()) {
t.Helper()
testutil.RequireDoltBinary(t)
beadsDir := filepath.Join(t.TempDir(), ".beads")
if err := os.MkdirAll(beadsDir, 0700); err != nil {
t.Fatalf("mkdir beads dir: %v", err)
}
t.Setenv("BEADS_DOLT_SHARED_SERVER", "0")
t.Setenv("BEADS_DOLT_AUTO_START", "1")
state, err := doltserver.Start(beadsDir)
if err != nil {
t.Fatalf("doltserver.Start: %v", err)
}
t.Cleanup(func() { _ = doltserver.Stop(beadsDir) })
ctx, cancel := testContext(t)
defer cancel()
store, err := New(ctx, &Config{
Path: filepath.Join(beadsDir, "dolt"),
BeadsDir: beadsDir,
CommitterName: "test",
CommitterEmail: "test@example.com",
Database: uniqueTestDBName(t),
ServerHost: "127.0.0.1",
ServerPort: state.Port,
ServerUser: "root",
CreateIfMissing: true, // creates and schema-inits the fresh database
MaxOpenConns: 1, // Required: DOLT_CHECKOUT is session-level
})
if err != nil {
t.Fatalf("New: %v", err)
}
t.Cleanup(func() { store.Close() })
if err := store.SetConfig(ctx, "issue_prefix", "test"); err != nil {
t.Fatalf("set issue_prefix: %v", err)
}
return store, func() {}
}
// TestWispSeesCustomTypeRegisteredInTransaction verifies that a wisp created
// in the same transaction that registers its custom type validates against
// the fresh registration. Wisp rows are written on the ignored-tables
// session, but the validation context (config, custom_types) must be read
// from the regular session, or in-transaction registration stays invisible
// (GH#5443).
func TestWispSeesCustomTypeRegisteredInTransaction(t *testing.T) {
store, cleanup := setupAnyServerStore(t)
defer cleanup()
ctx, cancel := testContext(t)
defer cancel()
wisp := &types.Issue{
Title: "custom-typed wisp",
Status: types.StatusOpen,
Priority: 2,
IssueType: types.IssueType("duty"),
Ephemeral: true,
}
batchWisp := &types.Issue{
Title: "custom-typed wisp via batch",
Status: types.StatusOpen,
Priority: 2,
IssueType: types.IssueType("duty"),
Ephemeral: true,
}
err := store.RunInTransaction(ctx, "register type then create wisps", func(tx storage.Transaction) error {
if err := tx.SetConfig(ctx, "types.custom", `["duty"]`); err != nil {
return err
}
if err := tx.CreateIssue(ctx, wisp, "test-user"); err != nil {
return err
}
return tx.CreateIssues(ctx, []*types.Issue{batchWisp}, "test-user")
})
if err != nil {
t.Fatalf("wisp create after in-tx type registration failed: %v", err)
}
for _, id := range []string{wisp.ID, batchWisp.ID} {
got, err := store.GetIssue(ctx, id)
if err != nil {
t.Fatalf("GetIssue(%s) failed for created wisp: %v", id, err)
}
if got.IssueType != types.IssueType("duty") {
t.Errorf("IssueType of %s = %q, want %q", id, got.IssueType, "duty")
}
}
}

View file

@ -3,7 +3,6 @@ package db
import (
"context"
"database/sql"
"encoding/json"
"errors"
"fmt"
"strconv"
@ -94,15 +93,8 @@ func (r *configSQLRepositoryImpl) SetConfig(ctx context.Context, key, value stri
//
// The caller supplies a transactional runner, so the row and its projection
// commit together or neither does.
switch key {
case "status.custom":
if err := issueops.SyncCustomStatusesTable(ctx, r.runner, value); err != nil {
return fmt.Errorf("db: SetConfig %s: syncing custom_statuses table: %w", key, err)
}
case "types.custom":
if err := issueops.SyncCustomTypesTable(ctx, r.runner, value); err != nil {
return fmt.Errorf("db: SetConfig %s: syncing custom_types table: %w", key, err)
}
if _, err := issueops.SyncConfigTables(ctx, r.runner, key, value); err != nil {
return fmt.Errorf("db: SetConfig %s: %w", key, err)
}
return nil
}
@ -182,15 +174,7 @@ func (r *configSQLRepositoryImpl) readCustomTypesConfig(ctx context.Context) ([]
if err != nil {
return nil, fmt.Errorf("db: GetCustomTypes: %w", err)
}
value = strings.TrimSpace(value)
if value == "" {
return nil, nil
}
var jsonTypes []string
if err := json.Unmarshal([]byte(value), &jsonTypes); err == nil {
return parseCustomTypesList(jsonTypes), nil
}
return parseCustomTypesList(strings.Split(value, ",")), nil
return issueops.ParseTypesConfigValue(value), nil
}
func unionWithYAMLCustomTypes(dbTypes, yamlTypes []string) []string {
@ -218,20 +202,6 @@ func unionWithYAMLCustomTypes(dbTypes, yamlTypes []string) []string {
return out
}
func parseCustomTypesList(in []string) []string {
out := make([]string, 0, len(in))
for _, t := range in {
t = strings.TrimSpace(t)
if t != "" {
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

@ -5,7 +5,6 @@ package embeddeddolt
import (
"context"
"database/sql"
"fmt"
"github.com/steveyegge/beads/internal/config"
"github.com/steveyegge/beads/internal/storage/domain"
@ -19,17 +18,8 @@ func (s *EmbeddedDoltStore) SetConfig(ctx context.Context, key, value string) er
return err
}
// Sync normalized tables when config keys change
switch key {
case "status.custom":
if err := issueops.SyncCustomStatusesTable(ctx, tx, value); err != nil {
return fmt.Errorf("syncing custom_statuses table: %w", err)
}
case "types.custom":
if err := issueops.SyncCustomTypesTable(ctx, tx, value); err != nil {
return fmt.Errorf("syncing custom_types table: %w", err)
}
}
return nil
_, err := issueops.SyncConfigTables(ctx, tx, key, value)
return err
})
}

View file

@ -264,17 +264,12 @@ func (t *embeddedTransaction) SetConfig(ctx context.Context, key, value string)
return err
}
// Sync normalized tables when config keys change
switch key {
case "status.custom":
t.dirty.MarkDirty("custom_statuses")
if err := issueops.SyncCustomStatusesTable(ctx, t.tx, value); err != nil {
return fmt.Errorf("syncing custom_statuses table: %w", err)
}
case "types.custom":
t.dirty.MarkDirty("custom_types")
if err := issueops.SyncCustomTypesTable(ctx, t.tx, value); err != nil {
return fmt.Errorf("syncing custom_types table: %w", err)
}
table, err := issueops.SyncConfigTables(ctx, t.tx, key, value)
if err != nil {
return err
}
if table != "" {
t.dirty.MarkDirty(table)
}
return nil
}

View file

@ -85,12 +85,7 @@ func ResolveCustomConfigInTx(ctx context.Context, tx DBTX) (statuses []types.Cus
}
if !typesFromTable {
if v := cfg["types.custom"]; v != "" {
var jsonTypes []string
if jsonErr := json.Unmarshal([]byte(v), &jsonTypes); jsonErr == nil {
customTypes = jsonTypes
} else {
customTypes = ParseCommaSeparatedList(v)
}
customTypes = ParseTypesConfigValue(v)
} else if yamlTypes := config.GetCustomTypesFromYAML(); len(yamlTypes) > 0 {
customTypes = yamlTypes
}
@ -291,13 +286,7 @@ func ResolveCustomTypesInTx(ctx context.Context, tx DBTX) ([]string, error) {
return customTypesYAMLFallback(config.GetCustomTypesFromYAML, err)
}
if value != "" {
// Try JSON array first (e.g. '["gate","convoy"]'), fall back to comma-separated.
var jsonTypes []string
if err := json.Unmarshal([]byte(value), &jsonTypes); err == nil {
fromDB = jsonTypes
} else {
fromDB = ParseCommaSeparatedList(value)
}
fromDB = ParseTypesConfigValue(value)
}
}
@ -388,9 +377,10 @@ func dedupePreservingOrder(in []string) []string {
return out
}
// SyncCustomStatusesTable replaces all rows in custom_statuses with parsed config value.
// Used by both DoltStore and EmbeddedDoltStore when "status.custom" config changes.
func SyncCustomStatusesTable(ctx context.Context, tx DBTX, value string) error {
// syncCustomStatusesTable replaces all rows in custom_statuses with parsed config value.
// Reached only through SyncConfigTables, which is the single entry point every
// SetConfig path uses; call that rather than this directly. Triggered when"status.custom" config changes.
func syncCustomStatusesTable(ctx context.Context, tx DBTX, value string) error {
if _, err := tx.ExecContext(ctx, "DELETE FROM custom_statuses"); err != nil {
return err
}
@ -410,16 +400,17 @@ func SyncCustomStatusesTable(ctx context.Context, tx DBTX, value string) error {
return nil
}
// SyncCustomTypesTable replaces all rows in custom_types with parsed config value.
// Used by both DoltStore and EmbeddedDoltStore when "types.custom" config changes.
func SyncCustomTypesTable(ctx context.Context, tx DBTX, value string) error {
// syncCustomTypesTable replaces all rows in custom_types with parsed config value.
// Reached only through SyncConfigTables, which is the single entry point every
// SetConfig path uses; call that rather than this directly. Triggered when"types.custom" config changes.
func syncCustomTypesTable(ctx context.Context, tx DBTX, value string) error {
if _, err := tx.ExecContext(ctx, "DELETE FROM custom_types"); err != nil {
return err
}
if value == "" {
return nil
}
names := parseTypesValue(value)
names := ParseTypesConfigValue(value)
for _, name := range names {
if _, err := tx.ExecContext(ctx, "INSERT INTO custom_types (name) VALUES (?)", name); err != nil {
return err
@ -428,8 +419,11 @@ func SyncCustomTypesTable(ctx context.Context, tx DBTX, value string) error {
return nil
}
// parseTypesValue tries JSON array first, then falls back to comma-separated.
func parseTypesValue(value string) []string {
// ParseTypesConfigValue parses a types.custom config value, accepting both
// the JSON-array form written by bd config set / pour (e.g. ["duty","ops"])
// and the legacy comma-separated form (duty,ops). Elements are trimmed and
// empties dropped.
func ParseTypesConfigValue(value string) []string {
value = strings.TrimSpace(value)
if value == "" {
return nil
@ -437,33 +431,38 @@ func parseTypesValue(value string) []string {
// Try JSON array first (e.g. '["gate","convoy"]')
var jsonTypes []string
if err := json.Unmarshal([]byte(value), &jsonTypes); err == nil {
return jsonTypes
var out []string
for _, t := range jsonTypes {
if t = strings.TrimSpace(t); t != "" {
out = append(out, t)
}
}
return out
}
// Fall back to comma-separated
return ParseCommaSeparatedList(value)
}
// EnsureCustomTypeInTx registers name as a custom type if it is not
// already a built-in type and not already in the custom_types table.
// This is used by bd mol pour/wisp to auto-register types that the
// formula system creates implicitly (e.g. "gate" for async coordination
// beads) so that operators don't have to run bd config set types.custom
// manually before pouring a formula with gate steps. See GH#3213.
func EnsureCustomTypeInTx(ctx context.Context, tx DBTX, name string) error {
if types.IssueType(name).IsValid() {
return nil
}
existing, err := ResolveCustomTypesInTx(ctx, tx)
if err != nil {
return err
}
for _, t := range existing {
if t == name {
return nil
// SyncConfigTables re-syncs the normalized lookup table backing a config
// key, if any (status.custom → custom_statuses, types.custom →
// custom_types). Reads of those sets are table-first, so every SetConfig
// path must keep the projection in step with the string value or stale
// table rows win forever. Returns the name of the synced table ("" when
// the key has no projection) so transactional callers can mark it dirty.
func SyncConfigTables(ctx context.Context, tx DBTX, key, value string) (string, error) {
switch key {
case "status.custom":
if err := syncCustomStatusesTable(ctx, tx, value); err != nil {
return "", fmt.Errorf("syncing custom_statuses table: %w", err)
}
return "custom_statuses", nil
case "types.custom":
if err := syncCustomTypesTable(ctx, tx, value); err != nil {
return "", fmt.Errorf("syncing custom_types table: %w", err)
}
return "custom_types", nil
}
_, err = tx.ExecContext(ctx, "INSERT INTO custom_types (name) VALUES (?)", name)
return err
return "", nil
}
// ResolveInfraTypesInTx reads infrastructure types from the database,

View file

@ -262,24 +262,37 @@ func CreateIssuesInTx(ctx context.Context, tx DBTX, issues []*types.Issue, actor
// CreateIssuesInTxWithResult creates issues and reports tables whose writes are
// only knowable after SQL reconciliation, such as child counter advances.
func CreateIssuesInTxWithResult(ctx context.Context, tx DBTX, issues []*types.Issue, actor string, opts storage.BatchCreateOptions) (CreateIssuesResult, error) {
bc, err := NewBatchContext(ctx, tx, opts)
if err != nil {
return CreateIssuesResult{}, err
}
return CreateIssuesInTxWithContext(ctx, tx, bc, issues, actor)
}
// CreateIssuesInTxWithContext is CreateIssuesInTxWithResult with a
// caller-supplied BatchContext. Callers that split config reads from row
// writes across SQL sessions (doltTransaction's wisp tier) build the context
// on the session that sees in-transaction config writes and pass it here.
// The caller's bc is not modified, so one context can serve several calls.
func CreateIssuesInTxWithContext(ctx context.Context, tx DBTX, bc *BatchContext, issues []*types.Issue, actor string) (CreateIssuesResult, error) {
opts := bc.Opts
filteredIssues, err := filterCreateIssuesMixedBucketDependencies(issues, opts)
if err != nil {
return CreateIssuesResult{}, err
}
issues = filteredIssues
bc, err := NewBatchContext(ctx, tx, opts)
if err != nil {
return CreateIssuesResult{}, err
}
// This function already runs a slice-wide ReconcileChildCounters below,
// covering every accepted issue; skip the redundant per-issue reconcile.
bc.SkipChildCounterReconcile = true
// Set the flag on a shallow copy so the caller's context keeps its own
// reconcile behavior.
batch := *bc
batch.SkipChildCounterReconcile = true
result := CreateIssuesResult{}
accepted := issues[:0:0]
for _, issue := range issues {
issueResult, err := CreateIssueInTxWithResult(ctx, tx, bc, issue, actor)
issueResult, err := CreateIssueInTxWithResult(ctx, tx, &batch, issue, actor)
if err != nil {
return CreateIssuesResult{}, err
}

View file

@ -403,28 +403,6 @@ func GetCustomStatusesTx(ctx context.Context, tx DBTX) ([]string, error) {
return types.CustomStatusNames(detailed), nil
}
// GetCustomTypesTx reads custom types from config within a transaction.
func GetCustomTypesTx(ctx context.Context, tx *sql.Tx) ([]string, error) {
var raw string
err := tx.QueryRowContext(ctx, "SELECT value FROM config WHERE `key` = ?", "types.custom").Scan(&raw)
if err == sql.ErrNoRows || raw == "" {
return nil, nil
}
if err != nil {
return nil, fmt.Errorf("failed to read custom_types config: %w", err)
}
var customTypes []string
if err := json.Unmarshal([]byte(raw), &customTypes); err != nil {
for _, s := range strings.Split(raw, ",") {
s = strings.TrimSpace(s)
if s != "" {
customTypes = append(customTypes, s)
}
}
}
return customTypes, nil
}
// ValidateMetadataIfConfigured checks metadata against the schema from config.
func ValidateMetadataIfConfigured(metadata json.RawMessage) error {
mode := config.MetadataValidationMode()

View file

@ -3,11 +3,11 @@ package schema
import (
"context"
"database/sql"
"encoding/json"
"fmt"
"log"
"strings"
"github.com/steveyegge/beads/internal/storage/issueops"
"github.com/steveyegge/beads/internal/types"
)
@ -52,7 +52,7 @@ func needsCustomTypesBackfill(ctx context.Context, db DBConn) (bool, error) {
if err != nil {
return false, err
}
return len(parseTypesValue(value)) > 0, nil
return len(issueops.ParseTypesConfigValue(value)) > 0, nil
}
func needsCustomStatusesBackfill(ctx context.Context, db DBConn) (bool, error) {
@ -105,11 +105,8 @@ func backfillCustomTypes(ctx context.Context, db DBConn) (bool, error) {
}
wrote := false
for _, name := range parseTypesValue(value) {
name = strings.TrimSpace(name)
if name == "" {
continue
}
// ParseTypesConfigValue already trims elements and drops empties.
for _, name := range issueops.ParseTypesConfigValue(value) {
res, err := db.ExecContext(ctx, "INSERT IGNORE INTO custom_types (name) VALUES (?)", name)
if err != nil {
return wrote, fmt.Errorf("inserting type %q: %w", name, err)
@ -159,23 +156,3 @@ func backfillCustomStatuses(ctx context.Context, db DBConn) (bool, error) {
}
return wrote, nil
}
func parseTypesValue(value string) []string {
value = strings.TrimSpace(value)
if value == "" {
return nil
}
var jsonTypes []string
if err := json.Unmarshal([]byte(value), &jsonTypes); err == nil {
return jsonTypes
}
parts := strings.Split(value, ",")
var result []string
for _, p := range parts {
p = strings.TrimSpace(p)
if p != "" {
result = append(result, p)
}
}
return result
}