Add NewPatternFromString and bundle.SetDefault; use it for volumes & dashboards (#2734)

## Changes
- New dyn.NewPatternFromString to construct pattern from strings.
- New bundle.SetDefault() for easier setting of defaults.
- Replace configure_dashboards_defaults.go and
configure_volume_defaults.go with new this new helper.

There could be slight behaviour change: we no longer ignore
IsCannotTraverseNilError error. Per team discussions, null should not be
set in yaml or python.

## Why
- It's more declarative, so less error-prone.
- The string syntax for patterns is easier to read (and write):
`"resources.dashboards.*.parent_path"` vs
`dyn.NewPattern(dyn.Key("resources"), dyn.Key("dashboards"),
dyn.AnyKey(), dyn.Key("parent_path"))`
- We're going to migrate many defaults from terraform, so need a compact
representation.

## Tests
Unit tests for old mutators were converted to acceptance tests in
#2733

Author: denik

bundle/config/mutator/resourcemutator/configure_dashboard_defaults.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/config/mutator/resourcemutator/configure_volume_defaults.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)
+}

bundle/config/mutator/resourcemutator/resource_mutator.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:]
 		}
 

bundle/set_default.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/path_string.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/path_string_test.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
+}