hclparse

type AutoIncludeDependency ¶

type AutoIncludeDependency struct {
	// Block is the original HCL block, preserved for serialization.
	Block      *hcl.Block
	Name       string
	ConfigPath string
}

AutoIncludeDependency represents a resolved dependency block from autoinclude. config_path has been evaluated (e.g. unit.vpc.path -> "/abs/path/to/.terragrunt-stack/vpc"). The original HCL block is preserved for writing all attributes (mock_outputs, etc.) into the generated file.

type AutoIncludeHCL ¶

type AutoIncludeHCL struct {
	Remain hcl.Body `hcl:",remain"`
}

AutoIncludeHCL represents the first-phase parse of an autoinclude block. The entire body is captured as remain because it may contain references to unit.*.path / stack.*.path variables that are only available after the first parsing pass extracts all unit/stack names and paths.

Example HCL:

autoinclude {
  dependency "vpc" {
    config_path = unit.vpc.path
  }
  inputs = {
    vpc_id = dependency.vpc.outputs.vpc_id
  }
}

func (a *AutoIncludeHCL) Resolve(evalCtx *hcl.EvalContext) (*AutoIncludeResolved, hcl.Diagnostics)

type AutoIncludeKind ¶ added in v1.0.4

type AutoIncludeKind string

AutoIncludeKind identifies whether a generated autoinclude file is unit-level or stack-level. The values intentionally match internal/component.{UnitKind,StackKind} but are defined here because internal/component -> pkg/config -> internal/hclparse is the established import direction; reusing the component constants would create a cycle.

const (
	// KindUnit selects the unit-level filename (terragrunt.autoinclude.hcl). Value matches component.UnitKind.
	KindUnit AutoIncludeKind = "unit"
	// KindStack selects the stack-level filename (terragrunt.autoinclude.stack.hcl). Value matches component.StackKind.
	KindStack AutoIncludeKind = "stack"
)

type AutoIncludeResolved ¶

type AutoIncludeResolved struct {
	// EvalCtx is the HCL evaluation context used during resolution,
	// preserved so the generator can evaluate non-deferred expressions.
	EvalCtx *hcl.EvalContext
	// RawBody is the original autoinclude HCL body, preserved so
	// the generator can write non-dependency content (inputs, etc.)
	// directly from the AST without evaluating dependency.* references.
	RawBody hcl.Body
	// SourceBytes are the bytes of the file RawBody was parsed from. Generation slices expressions by HCL byte ranges and must use these bytes, not the root stack file's bytes, when the autoinclude originated in an included file.
	SourceBytes []byte
	// Kind is KindUnit or KindStack and drives the generated filename (terragrunt.autoinclude.hcl vs terragrunt.autoinclude.stack.hcl).
	Kind         AutoIncludeKind
	Dependencies []AutoIncludeDependency
}

AutoIncludeResolved represents the second-phase resolved autoinclude content.

After the first parse extracts unit/stack names and paths, the autoinclude body is partially evaluated:

• dependency.config_path is resolved (references unit.*.path)
• dependency remain (mock_outputs etc) is preserved for generation
• inputs and other blocks are partially evaluated (local.* resolved, dependency.* preserved)

The RawBody is preserved for serializing the generated terragrunt.autoinclude.hcl file.

type ComponentRef ¶

type ComponentRef struct {
	Name string
	Path string
	// ChildRefs holds nested unit refs for stack components.
	// When a stack block references a source with a terragrunt.stack.hcl,
	// the child units within that stack are parsed and stored here.
	// This enables stack.stack_name.unit_name.path references.
	ChildRefs []ComponentRef
}

ComponentRef holds the path and name metadata for a unit or stack block, used to build the evaluation context for the second parsing phase.

func DiscoverStackChildUnits(fs vfs.FS, stackSourceDir, stackGenDir string) []ComponentRef

func ExtractStackRefs(stacks []*StackBlockHCL) []ComponentRef

func ExtractUnitRefs(units []*UnitBlockHCL) []ComponentRef

type Copier ¶

type Copier struct {
	// contains filtered or unexported fields
}

Copier copies HCL blocks from AST source to hclwrite output. When an eval context is set, attributes are partially evaluated (local.* resolved, dependency.* preserved). Without it, attributes are copied verbatim from source bytes.

func NewCopier() *Copier

func (c *Copier) CopyBlock(outBody *hclwrite.Body, block *hclsyntax.Block, srcBytes []byte)

func (c *Copier) WithEvalCtx(evalCtx *hcl.EvalContext) *Copier

type DirCreateError ¶

type DirCreateError struct {
	Err     error
	DirPath string
}

DirCreateError indicates a failure to create a directory.

func (e DirCreateError) Error() string

func (e DirCreateError) Unwrap() error

type DuplicateStackNameError ¶

type DuplicateStackNameError struct {
	Name string
}

DuplicateStackNameError indicates that multiple stacks with the same name were found after merging include blocks.

func (e DuplicateStackNameError) Error() string

type DuplicateUnitNameError ¶

type DuplicateUnitNameError struct {
	Name string
}

DuplicateUnitNameError indicates that multiple units with the same name were found after merging include blocks.

func (e DuplicateUnitNameError) Error() string

type EmptyArgError ¶ added in v1.0.4

type EmptyArgError struct {
	Func string
	Arg  string
}

EmptyArgError indicates that a required string argument was empty.

func (e EmptyArgError) Error() string

type EvalArgs ¶

type EvalArgs struct {
	EvalCtx  *hcl.EvalContext
	Deferred map[string]bool
	SrcBytes []byte
}

EvalArgs bundles the shared arguments for partial evaluation functions.

type FileDecodeError ¶

type FileDecodeError struct {
	Name   string
	Detail string
}

FileDecodeError indicates a failure to decode an HCL file into a struct.

func (e FileDecodeError) Error() string

type FileParseError ¶

type FileParseError struct {
	FilePath string
	Detail   string
}

FileParseError indicates a failure to parse an HCL file.

func (e FileParseError) Error() string

type FileReadError ¶

type FileReadError struct {
	Err      error
	FilePath string
}

FileReadError indicates a failure to read a file from the filesystem.

func (e FileReadError) Error() string

func (e FileReadError) Unwrap() error

type FileWriteError ¶

type FileWriteError struct {
	Err      error
	FilePath string
}

FileWriteError indicates a failure to write a file to the filesystem.

func (e FileWriteError) Error() string

func (e FileWriteError) Unwrap() error

type IncludeValidationError ¶

type IncludeValidationError struct {
	IncludeName string
	Reason      string
}

IncludeValidationError indicates that an included stack file violates constraints (e.g. defines locals or nested includes).

func (e IncludeValidationError) Error() string

type LocalEvalError ¶

type LocalEvalError struct {
	Name   string
	Detail string
}

LocalEvalError indicates a failure to evaluate a local variable.

func (e LocalEvalError) Error() string

type LocalsCycleError ¶

type LocalsCycleError struct {
	Names []string
}

LocalsCycleError indicates that locals have circular dependencies.

func (e LocalsCycleError) Error() string

type LocalsHCL ¶

type LocalsHCL struct {
	Remain hcl.Body `hcl:",remain"`
}

LocalsHCL captures the locals block body for iterative evaluation.

type LocalsMaxIterError ¶

type LocalsMaxIterError struct {
	MaxIterations int
	Remaining     int
}

LocalsMaxIterError indicates that locals evaluation exceeded the maximum iterations.

func (e LocalsMaxIterError) Error() string

type MalformedDependencyError ¶ added in v1.0.4

type MalformedDependencyError struct {
	Err      error
	FilePath string
	Name     string
	Reason   string
}

MalformedDependencyError indicates a dependency block in an autoinclude file is malformed. Err optionally carries the original HCL diagnostics so callers can extract position info via errors.As/Is.

func (e MalformedDependencyError) Error() string

func (e MalformedDependencyError) Unwrap() error

type ParseResult ¶

type ParseResult struct {
	// AutoIncludes maps component name -> resolved autoinclude (only for units/stacks
	// that had an autoinclude block). Dependencies have config_path resolved.
	AutoIncludes map[string]*AutoIncludeResolved
	// Units from the first-pass parse (name, source, path, values decoded).
	Units []*UnitBlockHCL
	// Stacks from the first-pass parse.
	Stacks []*StackBlockHCL
}

ParseResult holds the output of a two-pass parse of a terragrunt.stack.hcl file.

func ParseStackFile(fs vfs.FS, input *ParseStackFileInput) (*ParseResult, error)

func ParseStackFileFromPath(fs vfs.FS, stackDir string) (*ParseResult, error)

type ParseStackFileInput ¶

type ParseStackFileInput struct {
	Values   *cty.Value
	Filename string
	StackDir string
	Src      []byte
}

ParseStackFileInput holds the input for ParseStackFile.

type StackBlockHCL ¶

type StackBlockHCL struct {
	AutoInclude  *AutoIncludeHCL `hcl:"autoinclude,block"`
	NoStack      *bool           `hcl:"no_dot_terragrunt_stack,attr"`
	NoValidation *bool           `hcl:"no_validation,attr"`
	Values       *cty.Value      `hcl:"values,attr"`
	Name         string          `hcl:",label"`
	Source       string          `hcl:"source,attr"`
	Path         string          `hcl:"path,attr"`
}

StackBlockHCL represents the first-phase parse of a stack block. Same remain pattern as UnitBlockHCL.

type StackFileHCL ¶

type StackFileHCL struct {
	Locals   *LocalsHCL         `hcl:"locals,block"`
	Includes []*StackIncludeHCL `hcl:"include,block"`
	Stacks   []*StackBlockHCL   `hcl:"stack,block"`
	Units    []*UnitBlockHCL    `hcl:"unit,block"`
}

StackFileHCL represents the first-phase parse of a terragrunt.stack.hcl file. The autoinclude body inside each unit/stack block is captured as hcl.Body via remain, allowing deferred evaluation once unit/stack path variables are available.

type StackIncludeHCL ¶

type StackIncludeHCL struct {
	Name string `hcl:",label"`
	Path string `hcl:"path,attr"`
}

StackIncludeHCL represents an include block in a terragrunt.stack.hcl file. The path is evaluated immediately during the first parse pass.

type UnexpectedBodyTypeError ¶

type UnexpectedBodyTypeError struct {
	FilePath string
}

UnexpectedBodyTypeError indicates that an HCL file body was not the expected *hclsyntax.Body type. This typically occurs with JSON-format HCL files.

func (e UnexpectedBodyTypeError) Error() string

type UnitBlockHCL ¶

type UnitBlockHCL struct {
	AutoInclude  *AutoIncludeHCL `hcl:"autoinclude,block"`
	NoStack      *bool           `hcl:"no_dot_terragrunt_stack,attr"`
	NoValidation *bool           `hcl:"no_validation,attr"`
	Values       *cty.Value      `hcl:"values,attr"`
	Name         string          `hcl:",label"`
	Source       string          `hcl:"source,attr"`
	Path         string          `hcl:"path,attr"`
}

UnitBlockHCL represents the first-phase parse of a unit block. Known attributes are decoded directly. The autoinclude block body is captured in Remain for second-phase evaluation.