feat: component group configs (#476)

Author: reubeno

internal/app/azldev/core/components/resolver.go

@@ -9,6 +9,8 @@ import (
 	"log/slog"
 	"path"
 	"path/filepath"
+	"slices"
+	"sort"
 	"strings"
 
 	"github.com/bmatcuk/doublestar/v4"
@@ -458,6 +460,7 @@ func applyInheritedDefaultsToComponent(
 ) (result *projectconfig.ComponentConfig, err error) {
 	var distroVer projectconfig.DistroVersionDefinition
 
+	// Find the distro.
 	_, distroVer, err = env.Distro()
 	if err != nil {
 		return result, fmt.Errorf("failed to resolve current distro:\n%w", err)
@@ -467,6 +470,30 @@ func applyInheritedDefaultsToComponent(
 	result = &projectconfig.ComponentConfig{}
 	*result = deep.MustCopy(distroVer.DefaultComponentConfig)
 
+	// Find all component groups that this component belongs to and apply their defaults.
+	if groupNames, ok := env.Config().GroupsByComponent[component.Name]; ok {
+		// Sort the group names for deterministic layering of defaults.
+		sortedGroupNames := slices.Clone(groupNames)
+		sort.Strings(sortedGroupNames)
+
+		for _, groupName := range sortedGroupNames {
+			// Find the group.
+			groupConfig, ok := env.Config().ComponentGroups[groupName]
+			if !ok {
+				return result, fmt.Errorf("component group not found: %s", groupName)
+			}
+
+			// Apply its defaults.
+			err = result.MergeUpdatesFrom(&groupConfig.DefaultComponentConfig)
+			if err != nil {
+				return result, fmt.Errorf(
+					"failed to apply defaults from component group '%s' to config for component '%s':\n%w",
+					groupName, component.Name, err,
+				)
+			}
+		}
+	}
+
 	// Layer in the component's explicit config.
 	err = result.MergeUpdatesFrom(&component)
 	if err != nil {

internal/app/azldev/core/components/resolver_test.go

@@ -412,6 +412,149 @@ func TestGetComponentGroupByName_GroupWithMatchingSpecs(t *testing.T) {
 	assert.ElementsMatch(t, expectedComponents, group.Components)
 }
 
+func TestApplyInheritedDefaults_GroupDefaults(t *testing.T) {
+	// A component belongs to a group that defines build defaults.
+	// The group defaults should be layered between distro defaults and the component's own config.
+	env := testutils.NewTestEnv(t)
+
+	// Set up a component with its own build config.
+	component := projectconfig.ComponentConfig{
+		Name: "my-comp",
+		Build: projectconfig.ComponentBuildConfig{
+			With: []string{"feature-x"},
+		},
+	}
+	env.Config.Components[component.Name] = component
+
+	// Set up a group with default build config.
+	env.Config.ComponentGroups["my-group"] = projectconfig.ComponentGroupConfig{
+		Components: []string{"my-comp"},
+		DefaultComponentConfig: projectconfig.ComponentConfig{
+			Build: projectconfig.ComponentBuildConfig{
+				Without: []string{"docs"},
+			},
+		},
+	}
+	env.Config.GroupsByComponent["my-comp"] = []string{"my-group"}
+
+	filter := &components.ComponentFilter{IncludeAllComponents: true}
+
+	// Find!
+	result, err := components.NewResolver(env.Env).FindComponents(filter)
+	require.NoError(t, err)
+	require.Len(t, result.Components(), 1)
+
+	resolved := result.Components()[0].GetConfig()
+
+	// Should have the component's own With setting.
+	assert.Contains(t, resolved.Build.With, "feature-x")
+	// Should also have the group's Without setting.
+	assert.Contains(t, resolved.Build.Without, "docs")
+}
+
+func TestApplyInheritedDefaults_MultipleGroupsDeterministicOrder(t *testing.T) {
+	// A component belongs to two groups. Their defaults should be applied in
+	// sorted group-name order for deterministic behavior.
+	env := testutils.NewTestEnv(t)
+
+	component := projectconfig.ComponentConfig{Name: "my-comp"}
+	env.Config.Components[component.Name] = component
+
+	// Group "aaa" adds with=["from-aaa"].
+	env.Config.ComponentGroups["aaa"] = projectconfig.ComponentGroupConfig{
+		Components: []string{"my-comp"},
+		DefaultComponentConfig: projectconfig.ComponentConfig{
+			Build: projectconfig.ComponentBuildConfig{
+				With: []string{"from-aaa"},
+			},
+		},
+	}
+
+	// Group "zzz" adds with=["from-zzz"].
+	env.Config.ComponentGroups["zzz"] = projectconfig.ComponentGroupConfig{
+		Components: []string{"my-comp"},
+		DefaultComponentConfig: projectconfig.ComponentConfig{
+			Build: projectconfig.ComponentBuildConfig{
+				With: []string{"from-zzz"},
+			},
+		},
+	}
+
+	env.Config.GroupsByComponent["my-comp"] = []string{"zzz", "aaa"}
+
+	filter := &components.ComponentFilter{IncludeAllComponents: true}
+
+	result, err := components.NewResolver(env.Env).FindComponents(filter)
+	require.NoError(t, err)
+	require.Len(t, result.Components(), 1)
+
+	resolved := result.Components()[0].GetConfig()
+
+	// Both group defaults should be applied.
+	assert.Contains(t, resolved.Build.With, "from-aaa")
+	assert.Contains(t, resolved.Build.With, "from-zzz")
+}
+
+func TestApplyInheritedDefaults_ComponentOverridesGroupDefaults(t *testing.T) {
+	// When a component explicitly sets a field that is also set by its group's
+	// defaults, the component's value should take precedence via merging.
+	env := testutils.NewTestEnv(t)
+
+	component := projectconfig.ComponentConfig{
+		Name: "my-comp",
+		Build: projectconfig.ComponentBuildConfig{
+			Defines: map[string]string{"key": "comp-value"},
+		},
+	}
+	env.Config.Components[component.Name] = component
+
+	env.Config.ComponentGroups["my-group"] = projectconfig.ComponentGroupConfig{
+		Components: []string{"my-comp"},
+		DefaultComponentConfig: projectconfig.ComponentConfig{
+			Build: projectconfig.ComponentBuildConfig{
+				Defines: map[string]string{"key": "group-value", "other": "group-only"},
+			},
+		},
+	}
+	env.Config.GroupsByComponent["my-comp"] = []string{"my-group"}
+
+	filter := &components.ComponentFilter{IncludeAllComponents: true}
+
+	result, err := components.NewResolver(env.Env).FindComponents(filter)
+	require.NoError(t, err)
+	require.Len(t, result.Components(), 1)
+
+	resolved := result.Components()[0].GetConfig()
+
+	// The component's own value should override the group's value.
+	assert.Equal(t, "comp-value", resolved.Build.Defines["key"])
+	// The group's other defaults should still be present.
+	assert.Equal(t, "group-only", resolved.Build.Defines["other"])
+}
+
+func TestApplyInheritedDefaults_NoGroupMembership(t *testing.T) {
+	// A component that doesn't belong to any group should still resolve correctly
+	// (only distro defaults + component config).
+	env := testutils.NewTestEnv(t)
+
+	component := projectconfig.ComponentConfig{
+		Name: "standalone",
+		Build: projectconfig.ComponentBuildConfig{
+			With: []string{"my-feature"},
+		},
+	}
+	env.Config.Components[component.Name] = component
+
+	filter := &components.ComponentFilter{IncludeAllComponents: true}
+
+	result, err := components.NewResolver(env.Env).FindComponents(filter)
+	require.NoError(t, err)
+	require.Len(t, result.Components(), 1)
+
+	resolved := result.Components()[0].GetConfig()
+	assert.Contains(t, resolved.Build.With, "my-feature")
+}
+
 func TestFindAllSpecPaths_Nothing(t *testing.T) {
 	env := testutils.NewTestEnv(t)
 

internal/projectconfig/component.go

@@ -68,10 +68,19 @@ type SourceFileReference struct {
 // say in a command line interface. Note that a component group does not uniquely "own" its components; a
 // component may belong to multiple groups, and components need not belong to any group.
 type ComponentGroupConfig struct {
+	// A human-friendly description of this component group.
+	Description string `toml:"description,omitempty" json:"description,omitempty" jsonschema:"title=Description,description=Description of this component group"`
+
+	// List of explicitly included components, identified by name.
+	Components []string `toml:"components,omitempty" json:"components,omitempty" jsonschema:"title=Components,description=List of component names that are members of this group"`
+
 	// List of glob patterns specifying raw spec files that define components.
 	SpecPathPatterns []string `toml:"specs,omitempty" json:"specs,omitempty" validate:"dive,required" jsonschema:"title=Spec path patterns,description=List of glob patterns identifying local specs for components in this group,example=SPECS/**/.spec"`
 	// List of glob patterns specifying files to specifically ignore from spec selection.
 	ExcludedPathPatterns []string `toml:"excluded-paths,omitempty" json:"excludedPaths,omitempty" jsonschema:"title=Excluded path patterns,description=List of glob patterns identifying local paths to exclude from spec selection,example=build/**"`
+
+	// Default configuration to apply to component members of this group.
+	DefaultComponentConfig ComponentConfig `toml:"default-component-config,omitempty" json:"defaultComponentConfig,omitempty" jsonschema:"title=Default component configuration,description=Default component config inherited by all members of this component group"`
 }
 
 // Returns a copy of the component group config with relative file paths converted to absolute
@@ -93,6 +102,8 @@ func (g ComponentGroupConfig) WithAbsolutePaths(referenceDir string) ComponentGr
 		result.ExcludedPathPatterns[i] = makeAbsolute(referenceDir, result.ExcludedPathPatterns[i])
 	}
 
+	result.DefaultComponentConfig = *(result.DefaultComponentConfig.WithAbsolutePaths(referenceDir))
+
 	return result
 }
 

internal/projectconfig/component_test.go

@@ -106,6 +106,59 @@ func TestComponentConfigWithAbsolutePaths(t *testing.T) {
 	})
 }
 
+func TestComponentGroupConfigWithAbsolutePaths_DefaultComponentConfig(t *testing.T) {
+	const testRefDir = "/ref/dir"
+
+	t.Run("default config with relative spec path", func(t *testing.T) {
+		group := projectconfig.ComponentGroupConfig{
+			Components: []string{"comp-a"},
+			DefaultComponentConfig: projectconfig.ComponentConfig{
+				Spec: projectconfig.SpecSource{
+					SourceType: projectconfig.SpecSourceTypeLocal,
+					Path:       "specs/test.spec",
+				},
+			},
+		}
+
+		absGroup := group.WithAbsolutePaths(testRefDir)
+
+		// The default component config's spec path should be made absolute.
+		assert.Equal(t, "/ref/dir/specs/test.spec", absGroup.DefaultComponentConfig.Spec.Path)
+
+		// Members should be preserved.
+		assert.Equal(t, []string{"comp-a"}, absGroup.Components)
+	})
+
+	t.Run("default config with empty fields", func(t *testing.T) {
+		group := projectconfig.ComponentGroupConfig{
+			Components:             []string{"comp-a"},
+			DefaultComponentConfig: projectconfig.ComponentConfig{},
+		}
+
+		absGroup := group.WithAbsolutePaths(testRefDir)
+
+		// Empty default config should remain empty.
+		assert.Equal(t, projectconfig.ComponentConfig{}, absGroup.DefaultComponentConfig)
+	})
+
+	t.Run("default config with build settings", func(t *testing.T) {
+		group := projectconfig.ComponentGroupConfig{
+			DefaultComponentConfig: projectconfig.ComponentConfig{
+				Build: projectconfig.ComponentBuildConfig{
+					With:    []string{"tests"},
+					Without: []string{"docs"},
+				},
+			},
+		}
+
+		absGroup := group.WithAbsolutePaths(testRefDir)
+
+		// Build config should be preserved as-is (no paths to fix).
+		assert.Equal(t, []string{"tests"}, absGroup.DefaultComponentConfig.Build.With)
+		assert.Equal(t, []string{"docs"}, absGroup.DefaultComponentConfig.Build.Without)
+	})
+}
+
 func TestMergeComponentUpdates(t *testing.T) {
 	base := projectconfig.ComponentConfig{
 		Build: projectconfig.ComponentBuildConfig{