stack depednencies

Author: denis256

internal/hclparse/generate.go

@@ -109,35 +109,26 @@ func writeDependencyBlock(outBody *hclwrite.Body, dep AutoIncludeDependency, ori
 }
 
 // writeNonDependencyContent writes non-dependency attributes and blocks from
-// the autoinclude body. For each attribute:
-//   - If it references dependency.* variables, copy verbatim from source bytes
-//   - Otherwise, evaluate using evalCtx and write the literal value
-//   - Fallback to source bytes if evaluation fails
+// the autoinclude body. Each attribute expression is partially evaluated:
+// resolvable parts (locals, pure refs) become literals, while deferred parts
+// (dependency.*) keep their original source text. This enables mixed
+// expressions like "${local.env}-${dependency.vpc.outputs.vpc_id}" to be
+// partially resolved.
 //
 // Non-dependency blocks are always copied verbatim from source bytes.
 func writeNonDependencyContent(outBody *hclwrite.Body, body *hclsyntax.Body, srcBytes []byte, evalCtx *hcl.EvalContext) {
 	for _, attr := range sortedAttributes(body.Attributes) {
-		if hasDeferredVarRefs(attr.Expr) {
-			// Has dependency.* refs — copy verbatim.
-			exprBytes := rangeBytes(srcBytes, attr.Expr.Range())
-			outBody.SetAttributeRaw(attr.Name, rawTokens(exprBytes))
-		} else if evalCtx != nil {
-			// No deferred refs — try to evaluate.
-			val, diags := attr.Expr.Value(evalCtx)
-			if !diags.HasErrors() {
-				outBody.SetAttributeValue(attr.Name, val)
-			} else {
-				// Fallback to source bytes.
-				exprBytes := rangeBytes(srcBytes, attr.Expr.Range())
-				outBody.SetAttributeRaw(attr.Name, rawTokens(exprBytes))
-			}
-		} else {
+		if evalCtx == nil {
 			exprBytes := rangeBytes(srcBytes, attr.Expr.Range())
 			outBody.SetAttributeRaw(attr.Name, rawTokens(exprBytes))
+
+			continue
 		}
+
+		result := PartialEval(attr.Expr, srcBytes, evalCtx, deferredRoots)
+		outBody.SetAttributeRaw(attr.Name, rawTokens(result))
 	}
 
-	// Non-dependency blocks are still copied verbatim.
 	for _, block := range body.Blocks {
 		if block.Type == "dependency" {
 			continue
@@ -147,18 +138,6 @@ func writeNonDependencyContent(outBody *hclwrite.Body, body *hclsyntax.Body, src
 	}
 }
 
-// hasDeferredVarRefs returns true if the expression references any
-// dependency.* variables that cannot be evaluated at generation time.
-func hasDeferredVarRefs(expr hclsyntax.Expression) bool {
-	for _, traversal := range expr.Variables() {
-		if traversal.RootName() == "dependency" {
-			return true
-		}
-	}
-
-	return false
-}
-
 // copyBlockFromSource copies a block from the original AST to hclwrite output,
 // using source bytes for all attribute expressions.
 func copyBlockFromSource(outBody *hclwrite.Body, block *hclsyntax.Block, srcBytes []byte) {

internal/hclparse/parse.go

@@ -1,6 +1,8 @@
 package hclparse
 
 import (
+	"fmt"
+	"os"
 	"path/filepath"
 
 	"github.com/hashicorp/hcl/v2"
@@ -50,6 +52,11 @@ func ParseStackFile(src []byte, filename string, stackDir string, values *cty.Va
 		return nil, diags
 	}
 
+	// Process includes — merge included units/stacks.
+	if err := processStackIncludes(stackFile, stackDir); err != nil {
+		return nil, err
+	}
+
 	// Build component refs with absolute paths for the eval context.
 	// stackDir is the directory containing the terragrunt.stack.hcl file.
 	// Generated units go to stackDir/.terragrunt-stack/{unit.path}.
@@ -150,6 +157,37 @@ func evaluateLocals(body hcl.Body, evalCtx *hcl.EvalContext) {
 	}
 }
 
+// processStackIncludes resolves include blocks by parsing the included files
+// and merging their unit/stack blocks into the main stack file.
+func processStackIncludes(stackFile *StackFileHCL, stackDir string) error {
+	for _, inc := range stackFile.Includes {
+		includePath := inc.Path
+		if !filepath.IsAbs(includePath) {
+			includePath = filepath.Join(stackDir, includePath)
+		}
+
+		data, err := os.ReadFile(includePath)
+		if err != nil {
+			return fmt.Errorf("failed to read include %q: %w", inc.Name, err)
+		}
+
+		incFile, diags := hclsyntax.ParseConfig(data, includePath, hcl.Pos{Line: 1, Column: 1})
+		if diags.HasErrors() {
+			return fmt.Errorf("failed to parse include %q: %s", inc.Name, diags.Error())
+		}
+
+		included := &StackFileHCL{}
+		if decodeDiags := gohcl.DecodeBody(incFile.Body, nil, included); decodeDiags.HasErrors() {
+			return fmt.Errorf("failed to decode include %q: %s", inc.Name, decodeDiags.Error())
+		}
+
+		stackFile.Units = append(stackFile.Units, included.Units...)
+		stackFile.Stacks = append(stackFile.Stacks, included.Stacks...)
+	}
+
+	return nil
+}
+
 // buildRefsWithAbsPath creates ComponentRef values with paths resolved
 // to the absolute location under .terragrunt-stack/.
 func buildRefsWithAbsPath(stackTargetDir string, units []*UnitBlockHCL) []ComponentRef {

internal/hclparse/parse_test.go

@@ -576,6 +576,89 @@ unit "app" {
 	assert.Contains(t, content, "dependency.vpc.outputs.vpc_id")
 }
 
+func TestGenerateAutoIncludeFile_PartialEval(t *testing.T) {
+	t.Parallel()
+
+	// Mixed expressions: inputs object has both pure local refs and deferred
+	// dependency refs. The partial evaluator should resolve locals to literals
+	// while preserving dependency refs verbatim. A mixed template string tests
+	// per-part partial evaluation.
+	src := `
+locals {
+  env    = "production"
+  region = "us-east-1"
+}
+
+unit "vpc" {
+  source = "../catalog/units/vpc"
+  path   = "vpc"
+}
+
+unit "app" {
+  source = "../catalog/units/app"
+  path   = "app"
+
+  autoinclude {
+    dependency "vpc" {
+      config_path = unit.vpc.path
+
+      mock_outputs_allowed_terraform_commands = ["plan"]
+      mock_outputs = {
+        vpc_id = "mock-vpc-id"
+      }
+    }
+
+    # Mixed object: env is pure local, vpc_id is deferred dependency
+    inputs = {
+      env    = local.env
+      region = local.region
+      vpc_id = dependency.vpc.outputs.vpc_id
+    }
+
+    # Pure local attribute — fully evaluated
+    env_label = local.env
+
+    # Mixed template — partial eval per interpolation part
+    name_tag = "${local.env}-${dependency.vpc.outputs.vpc_id}-app"
+  }
+}
+`
+	srcBytes := []byte(src)
+
+	result, err := hclparse.ParseStackFile(srcBytes, "terragrunt.stack.hcl", "/project", nil)
+	require.NoError(t, err)
+
+	resolved, ok := result.AutoIncludes["app"]
+	require.True(t, ok)
+
+	tmpDir := t.TempDir()
+	appDir := filepath.Join(tmpDir, ".terragrunt-stack", "app")
+
+	err = hclparse.GenerateAutoIncludeFile(resolved, appDir, srcBytes, resolved.EvalCtx)
+	require.NoError(t, err)
+
+	generated, err := os.ReadFile(filepath.Join(appDir, hclparse.AutoIncludeFile))
+	require.NoError(t, err)
+
+	content := string(generated)
+
+	// env_label: pure local ref -> evaluated to literal
+	assert.Contains(t, content, `"production"`)
+	assert.NotContains(t, content, "local.env")
+
+	// inputs object: env and region resolved, vpc_id deferred
+	assert.Contains(t, content, `"us-east-1"`)
+	assert.NotContains(t, content, "local.region")
+	assert.Contains(t, content, "dependency.vpc.outputs.vpc_id")
+
+	// name_tag: mixed template -> "production-${dependency.vpc.outputs.vpc_id}-app"
+	assert.Contains(t, content, "production-${dependency.vpc.outputs.vpc_id}-app")
+
+	// Dependency block preserved
+	assert.Contains(t, content, `dependency "vpc"`)
+	assert.Contains(t, content, "mock_outputs")
+}
+
 func TestParseStackFile_StackChildUnitPath(t *testing.T) {
 	t.Parallel()