Add NewPatternFromString and bundle.SetDefault; use it for volumes & dashboards

bundle/config/mutator/resourcemutator/resource_mutator.go

@@ -18,7 +18,7 @@ import (
 //
 // If bundle is modified outside of 'resources' section, these changes are discarded.
 func applyInitializeMutators(ctx context.Context, b *bundle.Bundle) diag.Diagnostics {
-return bundle.ApplySeq(
+diags := bundle.ApplySeq(
  ctx,
  b,
  // Reads (typed): b.Config.RunAs, b.Config.Workspace.CurrentUser (validates run_as configuration)
@@ -35,16 +35,29 @@ func applyInitializeMutators(ctx context.Context, b *bundle.Bundle) diag.Diagnos
  // OR corresponding fields on ForEachTask if that is present
  // Overrides job compute settings with a specified cluster ID for development or testing
  OverrideCompute(),
+	)
+
+	if diags.HasError() {
+ return diags
+	}
 
- // Reads (dynamic): resources.dashboards.* (checks for existing parent_path and embed_credentials)
- // Updates (dynamic): resources.dashboards.*.parent_path (sets to workspace.resource_path if not set)
- // Updates (dynamic): resources.dashboards.*.embed_credentials (sets to false if not set)
- ConfigureDashboardDefaults(),
+	defaults := []struct {
+ pattern string
+ value any
+	}{
+ {"resources.dashboards.*.parent_path", b.Config.Workspace.ResourcePath},
+ {"resources.dashboards.*.embed_credentials", false},
+ {"resources.volumes.*.volume_type", "MANAGED"},
+	}
 
- // Reads (dynamic): resources.volumes.* (checks for existing volume_type)
- // Updates (dynamic): resources.volumes.*.volume_type (sets to "MANAGED" if not set)
- ConfigureVolumeDefaults(),
+	for _, defaultDef := range defaults {
+ diags = diags.Extend(bundle.SetDefault(ctx, b, defaultDef.pattern, defaultDef.value))
+ if diags.HasError() {
+ return diags
+ }
+	}
 
+	diags = diags.Extend(bundle.ApplySeq(ctx, b,
  ApplyPresets(),
 
  // Reads (typed): b.Config.Resources.Jobs (checks job configurations)
@@ -62,7 +75,9 @@ func applyInitializeMutators(ctx context.Context, b *bundle.Bundle) diag.Diagnos
  // Updates (dynamic): resources.*.*.permissions (removes permissions entries where user_name or service_principal_name matches current user)
  // Removes the current user from all resource permissions as the Terraform provider implicitly grants ownership
  FilterCurrentUser(),
-	)
+	))
+
+	return diags
 }
 
 // Normalization is applied multiple times if resource is modified during initialization

bundle/set_default.go

@@ -0,0 +1,61 @@
+package bundle
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/databricks/cli/libs/diag"
+	"github.com/databricks/cli/libs/dyn"
+)
+
+type setDefault struct {
+	pattern dyn.Pattern
+	key dyn.Path
+	value any
+}
+
+func SetDefaultMutator(pattern dyn.Pattern, key string, value any) Mutator {
+	return &setDefault{
+ pattern: pattern,
+ key: dyn.NewPath(dyn.Key(key)),
+ value: value,
+	}
+}
+
+func (m *setDefault) Name() string {
+	return fmt.Sprintf("SetDefaultMutator(%v, %v, %v)", m.pattern, m.key, m.value)
+}
+
+func (m *setDefault) Apply(ctx context.Context, b *Bundle) diag.Diagnostics {
+	err := b.Config.Mutate(func(v dyn.Value) (dyn.Value, error) {
+ return dyn.MapByPattern(v, m.pattern, func(p dyn.Path, v dyn.Value) (dyn.Value, error) {
+ _, err := dyn.GetByPath(v, m.key)
+ switch {
+ case dyn.IsNoSuchKeyError(err):
+ return dyn.SetByPath(v, m.key, dyn.V(m.value))
+ default:
+ return v, err
+ }
+ })
+	})
+	if err != nil {
+ return diag.FromErr(err)
+	}
+
+	return nil
+}
+
+func SetDefault(ctx context.Context, b *Bundle, pattern string, value any) diag.Diagnostics {
+	pat, err := dyn.NewPatternFromString(pattern)
+	if err != nil {
+ return diag.FromErr(fmt.Errorf("Internal error: invalid pattern: %s: %w", pattern, err))
+	}
+
+	pat, key := pat.SplitKey()
+	if pat == nil || key == "" {
+ return diag.FromErr(fmt.Errorf("Internal error: invalid pattern: %s", pattern))
+	}
+
+	m := SetDefaultMutator(pat, key, value)
+	return Apply(ctx, b, m)
+}

libs/dyn/path_string.go

@@ -39,7 +39,7 @@ func NewPathFromString(input string) (Path, error) {
 
 	for p != "" {
  // Every component may have a leading dot.
- if p != "" && p[0] == '.' {
+ if p[0] == '.' {
  p = p[1:]
  }
 

libs/dyn/path_string_test.go

@@ -88,6 +88,21 @@ func TestNewPathFromString(t *testing.T) {
  input: "foo[1]bar",
  err: errors.New("invalid path: foo[1]bar"),
  },
+ {
+ // * is parsed as regular string in NewPathFromString
+ input: "foo.*",
+ output: NewPath(Key("foo"), Key("*")),
+ },
+ {
+ // * is parsed as regular string in NewPathFromString
+ input: "foo.*.bar",
+ output: NewPath(Key("foo"), Key("*"), Key("bar")),
+ },
+ {
+ // This is an invalid path (but would be valid for patterns)
+ input: "foo[*].bar",
+ err: errors.New("invalid path: foo[*].bar"),
+ },
 	} {
  p, err := NewPathFromString(tc.input)
  if tc.err != nil {

libs/dyn/pattern.go

@@ -32,6 +32,25 @@ func NewPatternFromPath(p Path) Pattern {
 	return cs
 }
 
+// Split <pattern>.<string_key> into <pattern> and <string_key>
+// The last component must be dyn.Key() and there must be at least two components.
+func (p Pattern) SplitKey() (Pattern, string) {
+	if len(p) <= 1 {
+ return nil, ""
+	}
+	parent := p[:len(p)-1]
+	leaf := p[len(p)-1]
+	pc, ok := leaf.(pathComponent)
+	if !ok {
+ return nil, ""
+	}
+	key := pc.Key()
+	if key == "" {
+ return nil, ""
+	}
+	return parent, key
+}
+
 // Append appends the given components to the pattern.
 func (p Pattern) Append(cs ...patternComponent) Pattern {
 	out := make(Pattern, len(p)+len(cs))

libs/dyn/pattern_string.go

@@ -0,0 +1,102 @@
+package dyn
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+)
+
+// MustPatternFromString is like NewPatternFromString but panics on error.
+func MustPatternFromString(input string) Pattern {
+	p, err := NewPatternFromString(input)
+	if err != nil {
+ panic(err)
+	}
+	return p
+}
+
+// NewPatternFromString parses a pattern from a string.
+//
+// The string must be a sequence of keys and indices separated by dots.
+// Indices must be enclosed in square brackets.
+// The string may include a leading dot.
+// The wildcard character '*' can be used to match any key or index.
+//
+// Examples:
+// - foo.bar
+// - foo[1].bar
+// - foo.*.bar
+// - foo[*].bar
+// - .
+func NewPatternFromString(input string) (Pattern, error) {
+	var pattern Pattern
+
+	p := input
+
+	// Trim leading dot.
+	if p != "" && p[0] == '.' {
+ p = p[1:]
+	}
+
+	for p != "" {
+ // Every component may have a leading dot.
+ if p[0] == '.' {
+ p = p[1:]
+ }
+
+ if p == "" {
+ return nil, fmt.Errorf("invalid pattern: %s", input)
+ }
+
+ if p[0] == '[' {
+ // Find next ]
+ i := strings.Index(p, "]")
+ if i < 0 {
+ return nil, fmt.Errorf("invalid pattern: %s", input)
+ }
+
+ // Check for wildcard
+ if p[1:i] == "*" {
+ pattern = append(pattern, AnyIndex())
+ } else {
+ // Parse index
+ j, err := strconv.Atoi(p[1:i])
+ if err != nil {
+ return nil, fmt.Errorf("invalid pattern: %s", input)
+ }
+
+ // Append index
+ pattern = append(pattern, Index(j))
+ }
+
+ p = p[i+1:]
+
+ // The next character must be a . or [
+ if p != "" && strings.IndexAny(p, ".[") != 0 {
+ return nil, fmt.Errorf("invalid pattern: %s", input)
+ }
+ } else {
+ // Find next . or [
+ i := strings.IndexAny(p, ".[")
+ if i < 0 {
+ i = len(p)
+ }
+
+ if i == 0 {
+ return nil, fmt.Errorf("invalid pattern: %s", input)
+ }
+
+ // Check for wildcard
+ if p[:i] == "*" {
+ pattern = append(pattern, AnyKey())
+ } else {
+ // Append key
+ pattern = append(pattern, Key(p[:i]))
+ }
+
+ p = p[i:]
+ }
+	}
+
+	return pattern, nil
+}