feat: terragrunt hcl parse include

Author: denis256

internal/discovery/helpers.go

@@ -9,8 +9,12 @@ import (
 
 	"github.com/gruntwork-io/terragrunt/internal/component"
 	"github.com/gruntwork-io/terragrunt/internal/errors"
+	intHclparse "github.com/gruntwork-io/terragrunt/internal/hclparse"
 	"github.com/gruntwork-io/terragrunt/internal/util"
 	"github.com/gruntwork-io/terragrunt/pkg/config"
+	"github.com/hashicorp/hcl/v2"
+	"github.com/hashicorp/hcl/v2/hclsyntax"
+	"github.com/zclconf/go-cty/cty"
 )
 
 const (
@@ -220,6 +224,8 @@ func sanitizeReadFiles(files []string) []string {
 }
 
 // extractDependencyPaths extracts all dependency paths from a Terragrunt configuration.
+// It also checks for terragrunt.autoinclude.hcl in the same directory and extracts
+// dependency config_path values from it, so the DAG correctly orders units.
 func extractDependencyPaths(cfg *config.TerragruntConfig, c component.Component) ([]string, error) {
 	if cfg == nil {
 		return nil, nil
@@ -232,6 +238,12 @@ func extractDependencyPaths(cfg *config.TerragruntConfig, c component.Component)
 
 	deduped := make(map[string]struct{}, maxDedupLen)
 
+	// Check for autoinclude file and extract its dependency paths for the DAG.
+	autoIncludeDeps := ExtractAutoIncludeDependencyPaths(c.Path())
+	for _, dep := range autoIncludeDeps {
+		deduped[dep] = struct{}{}
+	}
+
 	errs := make([]error, 0, maxDedupLen)
 
 	for _, dependency := range cfg.TerragruntDependencies {
@@ -265,8 +277,16 @@ func extractDependencyPaths(cfg *config.TerragruntConfig, c component.Component)
 	}
 
 	depPaths := make([]string, 0, len(deduped))
+
 	for depPath := range deduped {
-		depPaths = append(depPaths, depPath)
+		// When the stack-dependencies experiment is active and the dependency
+		// path points to a stack (directory with terragrunt.stack.hcl), expand
+		// it to all constituent unit paths so the DAG correctly blocks on each unit.
+		if expandedPaths := ExpandStackDependency(depPath); len(expandedPaths) > 0 {
+			depPaths = append(depPaths, expandedPaths...)
+		} else {
+			depPaths = append(depPaths, depPath)
+		}
 	}
 
 	if len(errs) > 0 {
@@ -275,3 +295,101 @@ func extractDependencyPaths(cfg *config.TerragruntConfig, c component.Component)
 
 	return depPaths, nil
 }
+
+// ExpandStackDependency checks if a dependency path points to a stack directory.
+// If so, it reads the stack config and returns paths to all generated units
+// within .terragrunt-stack/. Returns nil if not a stack.
+func ExpandStackDependency(depPath string) []string {
+	stackFile := filepath.Join(depPath, config.DefaultStackFile)
+
+	if !util.FileExists(stackFile) {
+		return nil
+	}
+
+	// Read the stack file to discover unit paths.
+	// We only need the raw HCL to extract unit path attributes — no eval context needed.
+	data, err := os.ReadFile(stackFile)
+	if err != nil {
+		return nil
+	}
+
+	unitPaths := ExtractUnitPathsFromStackFile(data, depPath)
+
+	return unitPaths
+}
+
+// ExtractUnitPathsFromStackFile parses a stack file and returns absolute paths
+// to each unit's generated directory under .terragrunt-stack/.
+func ExtractUnitPathsFromStackFile(data []byte, stackDir string) []string {
+	// Use a minimal HCL parse to extract unit blocks and their path attributes.
+	// We import the internal hclparse package which can handle this.
+	result, err := intHclparse.ParseStackFile(data, filepath.Join(stackDir, config.DefaultStackFile), stackDir, nil)
+	if err != nil {
+		return nil
+	}
+
+	paths := make([]string, 0, len(result.Units))
+
+	for _, unit := range result.Units {
+		unitPath := filepath.Join(stackDir, config.StackDir, unit.Path)
+		paths = append(paths, unitPath)
+	}
+
+	return paths
+}
+
+// ExtractAutoIncludeDependencyPaths checks for a terragrunt.autoinclude.hcl file
+// in the given unit directory and extracts dependency config_path values.
+// This ensures the DAG sees dependencies defined in autoinclude files during
+// graph construction, even though they're not in the main terragrunt.hcl.
+func ExtractAutoIncludeDependencyPaths(unitDir string) []string {
+	autoIncludePath := filepath.Join(unitDir, config.DefaultAutoIncludeFile)
+
+	if !util.FileExists(autoIncludePath) {
+		return nil
+	}
+
+	data, err := os.ReadFile(autoIncludePath)
+	if err != nil {
+		return nil
+	}
+
+	// Minimal HCL parse — just extract dependency blocks and their config_path.
+	file, diags := hclsyntax.ParseConfig(data, autoIncludePath, hcl.Pos{Line: 1, Column: 1})
+	if diags.HasErrors() {
+		return nil
+	}
+
+	body, ok := file.Body.(*hclsyntax.Body)
+	if !ok {
+		return nil
+	}
+
+	var paths []string
+
+	for _, block := range body.Blocks {
+		if block.Type != "dependency" || len(block.Labels) == 0 {
+			continue
+		}
+
+		configPathAttr, exists := block.Body.Attributes["config_path"]
+		if !exists {
+			continue
+		}
+
+		// Evaluate config_path — it's already a resolved string literal in the generated file.
+		val, valDiags := configPathAttr.Expr.Value(nil)
+		if valDiags.HasErrors() || val.Type() != cty.String {
+			continue
+		}
+
+		depPath := val.AsString()
+		if !filepath.IsAbs(depPath) {
+			depPath = filepath.Clean(filepath.Join(unitDir, depPath))
+		}
+
+		paths = append(paths, util.ResolvePath(depPath))
+	}
+
+	return paths
+}

internal/discovery/helpers_test.go

@@ -0,0 +1,203 @@
+package discovery_test
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+
+	"github.com/gruntwork-io/terragrunt/internal/discovery"
+	"github.com/gruntwork-io/terragrunt/pkg/config"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestExpandStackDependency_NotAStack(t *testing.T) {
+	t.Parallel()
+
+	tmpDir := t.TempDir()
+
+	result := discovery.ExpandStackDependency(tmpDir)
+	assert.Nil(t, result)
+}
+
+func TestExpandStackDependency_NonexistentDir(t *testing.T) {
+	t.Parallel()
+
+	result := discovery.ExpandStackDependency("/nonexistent/path")
+	assert.Nil(t, result)
+}
+
+func TestExpandStackDependency_StackWithUnits(t *testing.T) {
+	t.Parallel()
+
+	tmpDir := t.TempDir()
+	stackHCL := `
+unit "vpc" {
+  source = "../units/vpc"
+  path   = "vpc"
+}
+
+unit "db" {
+  source = "../units/db"
+  path   = "db"
+}
+
+unit "app" {
+  source = "../units/app"
+  path   = "app"
+}
+`
+	require.NoError(t, os.WriteFile(
+		filepath.Join(tmpDir, config.DefaultStackFile),
+		[]byte(stackHCL),
+		0644,
+	))
+
+	result := discovery.ExpandStackDependency(tmpDir)
+
+	require.Len(t, result, 3)
+
+	for _, p := range result {
+		assert.Contains(t, p, config.StackDir)
+	}
+
+	expected := map[string]bool{
+		filepath.Join(tmpDir, config.StackDir, "vpc"): true,
+		filepath.Join(tmpDir, config.StackDir, "db"):  true,
+		filepath.Join(tmpDir, config.StackDir, "app"): true,
+	}
+
+	for _, p := range result {
+		assert.True(t, expected[p], "unexpected path: %s", p)
+	}
+}
+
+func TestExpandStackDependency_EmptyStack(t *testing.T) {
+	t.Parallel()
+
+	tmpDir := t.TempDir()
+
+	require.NoError(t, os.WriteFile(
+		filepath.Join(tmpDir, config.DefaultStackFile),
+		[]byte("# Empty stack\n"),
+		0644,
+	))
+
+	result := discovery.ExpandStackDependency(tmpDir)
+	assert.Empty(t, result)
+}
+
+func TestExtractUnitPathsFromStackFile(t *testing.T) {
+	t.Parallel()
+
+	data := []byte(`
+unit "vpc" {
+  source = "../units/vpc"
+  path   = "vpc"
+}
+
+unit "db" {
+  source = "../units/db"
+  path   = "db"
+}
+`)
+	stackDir := "/project/live/infra"
+
+	paths := discovery.ExtractUnitPathsFromStackFile(data, stackDir)
+
+	require.Len(t, paths, 2)
+	assert.Equal(t, filepath.Join(stackDir, config.StackDir, "vpc"), paths[0])
+	assert.Equal(t, filepath.Join(stackDir, config.StackDir, "db"), paths[1])
+}
+
+func TestExtractUnitPathsFromStackFile_InvalidHCL(t *testing.T) {
+	t.Parallel()
+
+	paths := discovery.ExtractUnitPathsFromStackFile([]byte(`invalid {{{`), "/project")
+	assert.Nil(t, paths)
+}
+
+func TestExtractAutoIncludeDependencyPaths_NoFile(t *testing.T) {
+	t.Parallel()
+
+	tmpDir := t.TempDir()
+
+	paths := discovery.ExtractAutoIncludeDependencyPaths(tmpDir)
+	assert.Nil(t, paths)
+}
+
+func TestExtractAutoIncludeDependencyPaths_WithDependency(t *testing.T) {
+	t.Parallel()
+
+	tmpDir := t.TempDir()
+
+	// Write a generated autoinclude file with a relative config_path
+	autoIncludeContent := `
+# Generated by Terragrunt. Do not edit manually.
+dependency "vpc" {
+  config_path = "../unit-w-outputs"
+}
+
+inputs = {
+  val = dependency.vpc.outputs.val
+}
+`
+	require.NoError(t, os.WriteFile(
+		filepath.Join(tmpDir, config.DefaultAutoIncludeFile),
+		[]byte(autoIncludeContent),
+		0644,
+	))
+
+	paths := discovery.ExtractAutoIncludeDependencyPaths(tmpDir)
+
+	require.Len(t, paths, 1)
+	// ../unit-w-outputs resolved relative to tmpDir
+	assert.Equal(t, filepath.Clean(filepath.Join(tmpDir, "..", "unit-w-outputs")), paths[0])
+}
+
+func TestExtractAutoIncludeDependencyPaths_MultipleDeps(t *testing.T) {
+	t.Parallel()
+
+	tmpDir := t.TempDir()
+
+	autoIncludeContent := `
+dependency "vpc" {
+  config_path = "../vpc"
+}
+
+dependency "db" {
+  config_path = "../database"
+}
+`
+	require.NoError(t, os.WriteFile(
+		filepath.Join(tmpDir, config.DefaultAutoIncludeFile),
+		[]byte(autoIncludeContent),
+		0644,
+	))
+
+	paths := discovery.ExtractAutoIncludeDependencyPaths(tmpDir)
+
+	require.Len(t, paths, 2)
+}
+
+func TestExtractAutoIncludeDependencyPaths_AbsolutePath(t *testing.T) {
+	t.Parallel()
+
+	tmpDir := t.TempDir()
+
+	autoIncludeContent := `
+dependency "vpc" {
+  config_path = "/absolute/path/to/vpc"
+}
+`
+	require.NoError(t, os.WriteFile(
+		filepath.Join(tmpDir, config.DefaultAutoIncludeFile),
+		[]byte(autoIncludeContent),
+		0644,
+	))
+
+	paths := discovery.ExtractAutoIncludeDependencyPaths(tmpDir)
+
+	require.Len(t, paths, 1)
+	assert.Equal(t, "/absolute/path/to/vpc", paths[0])
+}