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 []ComponentRef
}

ComponentRef holds name, path, and child refs.

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

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
	// contains filtered or unexported fields
}

EvalArgs bundles the shared arguments for partial evaluation functions.

type FileDecodeError ¶

type FileDecodeError struct {
	Err  error
	Name string
}

FileDecodeError indicates a failure to decode an HCL file into a struct; Err preserves the underlying diagnostics.

func (e FileDecodeError) Error() string

func (e FileDecodeError) Unwrap() error

type FileParseError ¶

type FileParseError struct {
	Err      error
	FilePath string
}

FileParseError indicates a failure to parse an HCL file; Err preserves the underlying diagnostics.

func (e FileParseError) Error() string

func (e FileParseError) Unwrap() error

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 {
	Err         error
	IncludeName string
	Reason      string
}

IncludeValidationError indicates that an included stack file violates constraints (e.g. defines locals or nested includes). Err preserves the underlying error (such as hcl.Diagnostics from include-path evaluation) so callers can extract it via errors.As.

func (e IncludeValidationError) Error() string

func (e IncludeValidationError) Unwrap() error

type LocalEvalError ¶

type LocalEvalError struct {
	Err  error
	Name string
}

LocalEvalError indicates a failure to evaluate a local variable; Err preserves the underlying diagnostics.

func (e LocalEvalError) Error() string

func (e LocalEvalError) Unwrap() error

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 is the locals block shell.

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 stores resolved autoincludes by component key.
	AutoIncludes map[string]*AutoIncludeResolved
	Units        []*UnitBlockHCL
	Stacks       []*StackBlockHCL
}

ParseResult holds the output of ParseStackFile.

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

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

type ParseStackFileInput ¶

type ParseStackFileInput struct {
	// Values is passed as the `values` variable in the parse context.
	Values *cty.Value
	// Variables come from production parsing and are merged for parse.
	Variables map[string]cty.Value
	// Functions are copied from the production parser eval context.
	Functions map[string]function.Function
	// Filename is the basename (not full path) used for parse diagnostics.
	Filename string
	// StackDir is used to resolve include paths.
	StackDir string
	// Src is the raw stack file bytes.
	Src []byte
}

ParseStackFileInput holds the input for ParseStackFile.

type PartialEvalDepthExceededError ¶ added in v1.0.6

type PartialEvalDepthExceededError struct {
	MaxDepth int
}

PartialEvalDepthExceededError indicates that PartialEval hit its recursion guard.

func (e PartialEvalDepthExceededError) Error() string

type PartialEvalUnresolvedError ¶ added in v1.0.6

type PartialEvalUnresolvedError struct {
	Err    error
	Reason string
}

PartialEvalUnresolvedError indicates that partial evaluation could not produce a final cty value.

func (e PartialEvalUnresolvedError) Error() string

func (e PartialEvalUnresolvedError) Unwrap() error

type StackBlockHCL ¶

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

StackBlockHCL is the eager stack block shape with deferred autoinclude content.

type StackFileHCL ¶

type StackFileHCL struct {
	Remain   hcl.Body           `hcl:",remain"`
	Locals   *LocalsHCL         `hcl:"locals,block"`
	Includes []*StackIncludeHCL `hcl:"include,block"`
}

StackFileHCL is the parsed skeleton: locals, includes, and Remain.

type StackIncludeHCL ¶

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

StackIncludeHCL stores include path as a lazy expression.

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 {
	Remain       hcl.Body        `hcl:",remain"`
	AutoInclude  *AutoIncludeHCL `hcl:"autoinclude,block"`
	NoStack      *bool           `hcl:"no_dot_terragrunt_stack,optional"`
	NoValidation *bool           `hcl:"no_validation,optional"`
	Values       *cty.Value      `hcl:"values,optional"`
	Source       string          `hcl:"source,attr"`
	Path         string          `hcl:"path,attr"`
	Name         string          `hcl:",label"`
}

UnitBlockHCL is the eager unit block shape with deferred autoinclude content.