chore: autoinclude config path fixes

Author: denis256

docs/src/data/changelog/v1.1.4/autoinclude-config-path-override.mdx

@@ -0,0 +1,10 @@
+---
+version: "v1.1.4"
+category: "bug-fixes"
+---
+
+#### Autoinclude overrides `config_path` set to a `values.*` attribute
+
+When a unit source declared `config_path = values.vpc_path` in a `dependency` block and the stack file's `autoinclude` replaced that dependency with a different `config_path`, Terragrunt raised an "Unsupported attribute" error because it tried to evaluate `values.vpc_path` before applying the autoinclude override. The `values` block no longer needed `vpc_path` since the autoinclude provided the path, but the evaluation order meant the error surfaced anyway.
+
+Terragrunt now detects dependency blocks overridden by a sibling autoinclude and bypasses their initial decode error, allowing the autoinclude replacement to resolve dependencies cleanly.

pkg/config/autoinclude_test.go

@@ -15,6 +15,7 @@ import (
 	"github.com/gruntwork-io/terragrunt/test/helpers/venvtest"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
+	"github.com/zclconf/go-cty/cty"
 )
 
 // tfInitCommand is the terraform command these autoinclude tests resolve dependency mock outputs against.
@@ -1404,3 +1405,195 @@ inputs = {
 	assert.Equal(t, "from-autoinclude", parsed.Inputs["vpc_id"], "autoinclude must win for vpc_id")
 	assert.Equal(t, "10.0.0.0/16", parsed.Inputs["cidr"], "original values.cidr must survive")
 }
+
+// When a unit source references values.vpc_path in a dependency config_path and the autoinclude overrides that entire dependency, the parse must succeed even though values.vpc_path is absent.
+func TestFoldSiblingAutoIncludeDeps_OverridesConfigPathFromValues(t *testing.T) {
+	t.Parallel()
+
+	tmpDir := t.TempDir()
+	cfgPath := filepath.Join(tmpDir, config.DefaultTerragruntConfigPath)
+
+	// Dependency target referenced by the autoinclude override.
+	require.NoError(t, os.MkdirAll(filepath.Join(tmpDir, "vpc"), 0755))
+	require.NoError(t, os.WriteFile(
+		filepath.Join(tmpDir, "vpc", config.DefaultTerragruntConfigPath),
+		[]byte(``), 0644,
+	))
+
+	const marker = "autoinclude-overrides-values-config-path"
+
+	// Unit references values.vpc_path, which does NOT exist in the values.
+	require.NoError(t, os.WriteFile(cfgPath, []byte(`
+dependency "vpc" {
+  config_path  = values.vpc_path
+  skip_outputs = true
+  mock_outputs = {
+    id = "from-unit"
+  }
+  mock_outputs_allowed_terraform_commands = ["init"]
+}
+
+inputs = {
+  vpc_id = dependency.vpc.outputs.id
+}
+`), 0644))
+
+	// Autoinclude overrides the dependency with a valid config_path.
+	autoIncludePath := filepath.Join(tmpDir, config.DefaultAutoIncludeFile)
+	require.NoError(t, os.WriteFile(autoIncludePath, []byte(`
+dependency "vpc" {
+  config_path  = "./vpc"
+  skip_outputs = true
+  mock_outputs = {
+    id = "`+marker+`"
+  }
+  mock_outputs_allowed_terraform_commands = ["init"]
+}
+`), 0644))
+
+	// Values that intentionally omit vpc_path.
+	require.NoError(t, os.WriteFile(filepath.Join(tmpDir, "terragrunt.values.hcl"), []byte(`
+region = "us-east-1"
+`), 0644))
+
+	ctx, pctx := newTestParsingContext(t, venvtest.NewOSWithEmptyEnv(), cfgPath)
+	pctx.Experiments.EnableExperiment(experiment.StackDependencies)
+	pctx.OriginalTerraformCommand = tfInitCommand
+
+	values := cty.ObjectVal(map[string]cty.Value{
+		"region": cty.StringVal("us-east-1"),
+	})
+	pctx.Values = &values
+
+	l := logger.CreateLogger()
+
+	parsed, err := config.ParseConfigFile(ctx, pctx, l, cfgPath, nil)
+	require.NoError(t, err, "autoinclude dependency override must suppress the unresolvable values.vpc_path")
+	require.NotNil(t, parsed)
+	assert.Equal(t, marker, parsed.Inputs["vpc_id"], "autoinclude's mock output must win")
+}
+
+// A unit with two deps—one overridden by autoinclude and one valid—must resolve both.
+func TestFoldSiblingAutoIncludeDeps_OverridesConfigPathMixedDeps(t *testing.T) {
+	t.Parallel()
+
+	tmpDir := t.TempDir()
+	cfgPath := filepath.Join(tmpDir, config.DefaultTerragruntConfigPath)
+
+	for _, sub := range []string{"vpc", "db"} {
+		require.NoError(t, os.MkdirAll(filepath.Join(tmpDir, sub), 0755))
+		require.NoError(t, os.WriteFile(
+			filepath.Join(tmpDir, sub, config.DefaultTerragruntConfigPath),
+			[]byte(``), 0644,
+		))
+	}
+
+	// "vpc" references an absent values.vpc_path; "db" has a valid literal path.
+	require.NoError(t, os.WriteFile(cfgPath, []byte(`
+dependency "vpc" {
+  config_path  = values.vpc_path
+  skip_outputs = true
+  mock_outputs = {
+    id = "unit-vpc"
+  }
+  mock_outputs_allowed_terraform_commands = ["init"]
+}
+
+dependency "db" {
+  config_path  = "./db"
+  skip_outputs = true
+  mock_outputs = {
+    id = "unit-db"
+  }
+  mock_outputs_allowed_terraform_commands = ["init"]
+}
+
+inputs = {
+  vpc_id = dependency.vpc.outputs.id
+  db_id  = dependency.db.outputs.id
+}
+`), 0644))
+
+	// Autoinclude overrides only "vpc".
+	autoIncludePath := filepath.Join(tmpDir, config.DefaultAutoIncludeFile)
+	require.NoError(t, os.WriteFile(autoIncludePath, []byte(`
+dependency "vpc" {
+  config_path  = "./vpc"
+  skip_outputs = true
+  mock_outputs = {
+    id = "autoinclude-vpc"
+  }
+  mock_outputs_allowed_terraform_commands = ["init"]
+}
+`), 0644))
+
+	ctx, pctx := newTestParsingContext(t, venvtest.NewOSWithEmptyEnv(), cfgPath)
+	pctx.Experiments.EnableExperiment(experiment.StackDependencies)
+	pctx.OriginalTerraformCommand = tfInitCommand
+
+	values := cty.ObjectVal(map[string]cty.Value{
+		"region": cty.StringVal("us-east-1"),
+	})
+	pctx.Values = &values
+
+	l := logger.CreateLogger()
+
+	parsed, err := config.ParseConfigFile(ctx, pctx, l, cfgPath, nil)
+	require.NoError(t, err, "mixed deps must resolve when autoinclude overrides the unresolvable one")
+	require.NotNil(t, parsed)
+	assert.Equal(t, "autoinclude-vpc", parsed.Inputs["vpc_id"], "autoinclude must win for vpc")
+	assert.Equal(t, "unit-db", parsed.Inputs["db_id"], "unit's own db dep must survive")
+}
+
+// When an autoinclude overrides a different dep than the one that fails, the parse must still fail.
+func TestFoldSiblingAutoIncludeDeps_NonOverriddenFailureStillErrors(t *testing.T) {
+	t.Parallel()
+
+	tmpDir := t.TempDir()
+	cfgPath := filepath.Join(tmpDir, config.DefaultTerragruntConfigPath)
+
+	require.NoError(t, os.MkdirAll(filepath.Join(tmpDir, "other"), 0755))
+	require.NoError(t, os.WriteFile(
+		filepath.Join(tmpDir, "other", config.DefaultTerragruntConfigPath),
+		[]byte(``), 0644,
+	))
+
+	// "vpc" references an absent values.vpc_path; no autoinclude overrides it.
+	require.NoError(t, os.WriteFile(cfgPath, []byte(`
+dependency "vpc" {
+  config_path  = values.vpc_path
+  skip_outputs = true
+  mock_outputs = {
+    id = "unit-vpc"
+  }
+  mock_outputs_allowed_terraform_commands = ["init"]
+}
+`), 0644))
+
+	// Autoinclude overrides only "other", not "vpc".
+	autoIncludePath := filepath.Join(tmpDir, config.DefaultAutoIncludeFile)
+	require.NoError(t, os.WriteFile(autoIncludePath, []byte(`
+dependency "other" {
+  config_path  = "./other"
+  skip_outputs = true
+  mock_outputs = {
+    id = "autoinclude-other"
+  }
+  mock_outputs_allowed_terraform_commands = ["init"]
+}
+`), 0644))
+
+	ctx, pctx := newTestParsingContext(t, venvtest.NewOSWithEmptyEnv(), cfgPath)
+	pctx.Experiments.EnableExperiment(experiment.StackDependencies)
+	pctx.OriginalTerraformCommand = tfInitCommand
+
+	values := cty.ObjectVal(map[string]cty.Value{
+		"region": cty.StringVal("us-east-1"),
+	})
+	pctx.Values = &values
+
+	l := logger.CreateLogger()
+
+	_, err := config.ParseConfigFile(ctx, pctx, l, cfgPath, nil)
+	require.Error(t, err, "a non-overridden dep with unresolvable config_path must still fail")
+}

pkg/config/config.go

@@ -1838,6 +1838,16 @@ func decodeAsTerragruntConfigFile(
 	}
 
 	dependencies, err := decodeDependencyBlocks(file, evalContext, pctx.Experiments)
+	if err != nil && hasSiblingAutoInclude(pctx) {
+		overrides := siblingAutoIncludeDepNames(pctx)
+		if len(overrides) > 0 {
+			dependencies, err = decodeDependencyBlocks(
+				file, evalContext, pctx.Experiments,
+				hclparse.WithSkipLabelsOnError(overrides),
+			)
+		}
+	}
+
 	if err != nil {
 		return &terragruntConfig, err
 	}

pkg/config/dependency.go

@@ -29,6 +29,7 @@ import (
 
 	"github.com/gruntwork-io/terragrunt/internal/getter"
 	"github.com/hashicorp/hcl/v2"
+	"github.com/hashicorp/hcl/v2/hclsyntax"
 	"github.com/zclconf/go-cty/cty"
 	"github.com/zclconf/go-cty/cty/gocty"
 	ctyjson "github.com/zclconf/go-cty/cty/json"
@@ -263,8 +264,9 @@ func decodeDependencyBlocks(
 	file *hclparse.File,
 	evalContext *hcl.EvalContext,
 	experiments experiment.Experiments,
+	opts ...hclparse.ExpandOption,
 ) (Dependencies, error) {
-	instances, err := file.ExpandBlocks(MetadataDependency, &Dependency{}, evalContext)
+	instances, err := file.ExpandBlocks(MetadataDependency, &Dependency{}, evalContext, opts...)
 	if err != nil {
 		return nil, err
 	}
@@ -313,8 +315,21 @@ func decodeAndRetrieveOutputs(
 	}
 
 	dependencies, err := decodeDependencyBlocks(file, evalParsingContext, pctx.Experiments)
-	if err != nil {
-		return nil, err
+	if err != nil && hasSiblingAutoInclude(pctx) {
+		// When a sibling autoinclude overrides dependency blocks, the unit source may
+		// reference values.* attributes the override makes unnecessary. Skip overridden
+		// blocks on retry; foldSiblingAutoIncludeDeps fills them in below.
+		overrides := siblingAutoIncludeDepNames(pctx)
+		if len(overrides) > 0 {
+			dependencies, err = decodeDependencyBlocks(
+				file, evalParsingContext, pctx.Experiments,
+				hclparse.WithSkipLabelsOnError(overrides),
+			)
+		}
+
+		if err != nil {
+			return nil, err
+		}
 	}
 
 	decodedDependency := TerragruntDependency{Dependencies: dependencies}
@@ -2205,6 +2220,44 @@ func parseAutoIncludeFileCached(
 	return file, nil
 }
 
+// siblingAutoIncludeDepNames extracts dependency block labels from the sibling autoinclude file via a lightweight HCL parse. Returns nil when no autoinclude is registered, the file is absent, or it cannot be parsed.
+func siblingAutoIncludeDepNames(pctx *ParsingContext) map[string]bool {
+	if !hasSiblingAutoInclude(pctx) {
+		return nil
+	}
+
+	autoPath := pctx.TrackInclude.AutoIncludeOverride.Path
+
+	data, err := vfs.ReadFile(pctx.Venv.FS, autoPath)
+	if err != nil {
+		return nil
+	}
+
+	file, diags := hclsyntax.ParseConfig(data, autoPath, hcl.Pos{Line: 1, Column: 1})
+	if diags.HasErrors() {
+		return nil
+	}
+
+	body, ok := file.Body.(*hclsyntax.Body)
+	if !ok {
+		return nil
+	}
+
+	names := make(map[string]bool)
+
+	for _, block := range body.Blocks {
+		if block.Type == MetadataDependency && len(block.Labels) > 0 {
+			names[block.Labels[0]] = true
+		}
+	}
+
+	if len(names) == 0 {
+		return nil
+	}
+
+	return names
+}
+
 // IsValidConfigPath checks if a cty.Value is a valid, usable config path.
 func IsValidConfigPath(v cty.Value) bool {
 	if v.IsNull() || !v.IsWhollyKnown() || !v.Type().Equals(cty.String) {

pkg/config/hclparse/expansion.go

@@ -38,7 +38,8 @@ const (
 const DefaultMaxInstances = 1_000_000
 
 type expandConfig struct {
-	maxInstances int
+	skipLabelsOnError map[string]bool
+	maxInstances      int
 }
 
 // ExpandOption adjusts how [ExpandBlock] expands a block.
@@ -52,6 +53,13 @@ func WithMaxInstances(maxInstances int) ExpandOption {
 	}
 }
 
+// WithSkipLabelsOnError silently drops a block whose first label is in the set when its decode fails, instead of propagating the error. This lets callers skip blocks whose attributes are unresolvable because an autoinclude will replace them.
+func WithSkipLabelsOnError(labels map[string]bool) ExpandOption {
+	return func(cfg *expandConfig) {
+		cfg.skipLabelsOnError = labels
+	}
+}
+
 // ExpansionBlock is the decoded expansion sub-block of a dependency, unit, or stack
 // block. It stays nil unless the block declares expansion.
 type ExpansionBlock struct {
@@ -111,6 +119,11 @@ func (file *File) ExpandBlocks(
 		}
 	}
 
+	cfg := expandConfig{maxInstances: DefaultMaxInstances}
+	for _, opt := range opts {
+		opt(&cfg)
+	}
+
 	labels := labelFields(reflect.TypeOf(out).Elem())
 	labelNames := make([]string, 0, len(labels))
 
@@ -134,6 +147,11 @@ func (file *File) ExpandBlocks(
 			continue
 		}
 
+		// Drop blocks whose label matches the skip set on decode failure.
+		if cfg.skipLabelsOnError != nil && len(block.Labels) > 0 && cfg.skipLabelsOnError[block.Labels[0]] {
+			continue
+		}
+
 		var blockDiags hcl.Diagnostics
 		if !errors.As(err, &blockDiags) {
 			return nil, err