Support for Terraform Search (.tfquery.hcl) files (#469)

* Search: TF-27258: chore: add initial set of files for earlydecoder/search

* feat(tfsearch): TF-26847 TF-27259: Added: static tfsearch schemas

* Search: TF-27258: feat: complete earlydecoder functionality for search

* Search: TF-27258: fix: Add license header

* Search: TF-27258: test: fix incorrect test and update test data

* feat(tfsearch): TF-26847 TF-27259: Modified: include_resource constraint

* feat(tfsearch): TF-26847 TF-27259: Modified: limit constraint

* feat(tfsearch): TF-26847 TF-27259: Modified: added config block to list block

* feat(tfsearch): TF-26847 TF-27259: Modified: added schema validations for config and provider

* feat(tfsearch): TF-26847 TF-27259: Modified: allow include_resource to take values from local & variables

* feat(tfsearch): TF-26847 TF-27288: Added: dynamic schema for provider block

* feat(tfsearch): TF-26847 TF-27260: Added: dynamic list type of list block as per available providers

* feat(tfsearch): TF-26847 TF-27260: Modified: todo comment with details

* feat(tfsearch): TF-26847 TF-27260: Modified: wip dynamic list config

* Added provider blocking processing

* Enable dynamic auto complete for list block

* Remove TODOs that are done

* feat(tfsearch): TF-26847 TF-27260: Fixed: test cases

* feat(tfsearch): Modified: terraform-json version to  pseudo-version

* feat(tfsearch): Modified: ran go fmt

* Update testcases

* feat(tfsearch): TF-26847: Modified: Ran 'go generate ./schema

* Merge branch 'feature/tfsearch-TF-26847' of github.com:hashicorp/terraform-schema into feature/tfsearch-TF-26847

* feat(tfsearch): TF-26847: Modified: added terraform version in meta

* feature/tfsearch-TF-26847: test: Add test for search_schema_merge

* feat(tfsearch): TF-26847: Fixed: lint error

* feat(tfsearch): TF-26847: Bumped: terraform-json

* Search: TF-27258: fix: Remove static config block from list

* Search: TF-27258: fix: Remove provider schema attributes from top level list schema

* Search: TF-27258: test: update testcases for search

* feat(tfsearch): TF-26847: Modified: static config block

* feat(tfsearch): TF-26847: Modified: removed deprecated version field in provider

* feat(tfsearch): TF-26847: Modified: dependent body config

* feat(tfsearch): TF-26847: Modified: removed second dependency key list config

* feat(tfsearch): TF-26847: Modified: taking provider requirements from module meta

---------

Co-authored-by: sunnyhashi <[email protected]>

Author: anubhav-goel

earlydecoder/search/decoder.go

@@ -0,0 +1,65 @@
+// Copyright (c) HashiCorp, Inc.
+// SPDX-License-Identifier: MPL-2.0
+
+package earlydecoder
+
+import (
+	"sort"
+	"strings"
+
+	"github.com/hashicorp/hcl/v2"
+	tfaddr "github.com/hashicorp/terraform-registry-address"
+	"github.com/hashicorp/terraform-schema/search"
+)
+
+func LoadSearch(path string, files map[string]*hcl.File) (*search.Meta, map[string]hcl.Diagnostics) {
+	filenames := make([]string, 0)
+	diags := make(map[string]hcl.Diagnostics, 0)
+
+	mod := newDecodedSearch()
+	for filename, f := range files {
+		filenames = append(filenames, filename)
+		if isSearchFile(filename) {
+			diags[filename] = loadSearchFromFile(f, mod)
+		}
+	}
+
+	sort.Strings(filenames)
+
+	variables := make(map[string]search.Variable)
+	for key, variable := range mod.Variables {
+		variables[key] = *variable
+	}
+
+	lists := make(map[string]search.List)
+	for key, list := range mod.List {
+		lists[key] = *list
+	}
+
+	refs := make(map[search.ProviderRef]tfaddr.Provider, 0)
+
+	for _, cfg := range mod.ProviderConfigs {
+		src := refs[search.ProviderRef{
+			LocalName: cfg.Name,
+		}]
+		if cfg.Alias != "" {
+			refs[search.ProviderRef{
+				LocalName: cfg.Name,
+				Alias:     cfg.Alias,
+			}] = src
+		}
+	}
+
+	return &search.Meta{
+		Path:               path,
+		Filenames:          filenames,
+		Variables:          variables,
+		Lists:              lists,
+		ProviderReferences: refs,
+	}, diags
+}
+
+func isSearchFile(name string) bool {
+	return strings.HasSuffix(name, ".tfquery.hcl") ||
+		strings.HasSuffix(name, ".tfquery.hcl.json")
+}

earlydecoder/search/decoder_test.go

@@ -0,0 +1,160 @@
+// Copyright (c) HashiCorp, Inc.
+// SPDX-License-Identifier: MPL-2.0
+
+package earlydecoder
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/google/go-cmp/cmp"
+	"github.com/hashicorp/go-version"
+	"github.com/hashicorp/hcl/v2"
+	"github.com/hashicorp/hcl/v2/hclsyntax"
+	tfaddr "github.com/hashicorp/terraform-registry-address"
+	"github.com/hashicorp/terraform-schema/search"
+	"github.com/zclconf/go-cty-debug/ctydebug"
+	"github.com/zclconf/go-cty/cty"
+)
+
+type testCase struct {
+	name          string
+	cfg           string
+	fileName      string
+	expectedMeta  *search.Meta
+	expectedError map[string]hcl.Diagnostics
+}
+
+var customComparer = []cmp.Option{
+	cmp.Comparer(compareVersionConstraint),
+	ctydebug.CmpOptions,
+}
+
+var fileName = "test.tfquery.hcl"
+
+func TestLoadSearch(t *testing.T) {
+	path := t.TempDir()
+
+	testCases := []testCase{
+		{
+			"empty config",
+			``,
+			fileName,
+			&search.Meta{
+				Path:               path,
+				Filenames:          []string{fileName},
+				Variables:          map[string]search.Variable{},
+				Lists:              map[string]search.List{},
+				ProviderReferences: map[search.ProviderRef]tfaddr.Provider{},
+			},
+			map[string]hcl.Diagnostics{fileName: nil},
+		},
+		{
+			"variables",
+			`variable "example" {
+		 type    = string
+		 default = "default_value"
+		}
+		
+		variable "example2" {
+		 description = "description"
+		 sensitive   = true
+		}`,
+			fileName,
+			&search.Meta{
+
+				Path:      path,
+				Filenames: []string{fileName},
+				Variables: map[string]search.Variable{
+					"example": {
+						Type:         cty.String,
+						DefaultValue: cty.StringVal("default_value"),
+					},
+					"example2": {
+						Type:        cty.DynamicPseudoType,
+						Description: "description",
+						IsSensitive: true,
+					},
+				},
+				Lists:              map[string]search.List{},
+				ProviderReferences: map[search.ProviderRef]tfaddr.Provider{},
+			},
+			map[string]hcl.Diagnostics{fileName: nil},
+		},
+	}
+
+	runTestCases(testCases, t, path)
+
+}
+
+func runTestCases(testCases []testCase, t *testing.T, path string) {
+	for i, tc := range testCases {
+		t.Run(fmt.Sprintf("%d-%s", i, tc.name), func(t *testing.T) {
+			f, diags := hclsyntax.ParseConfig([]byte(tc.cfg), tc.fileName, hcl.InitialPos)
+			if len(diags) > 0 {
+				t.Fatal(diags)
+			}
+			files := map[string]*hcl.File{
+				tc.fileName: f,
+			}
+
+			var fdiags map[string]hcl.Diagnostics
+			meta, fdiags := LoadSearch(path, files)
+
+			if diff := cmp.Diff(tc.expectedError, fdiags, customComparer...); diff != "" {
+				t.Fatalf("expected errors doesn't match: %s", diff)
+			}
+
+			if diff := cmp.Diff(tc.expectedMeta, meta, customComparer...); diff != "" {
+				t.Fatalf("search meta doesn't match: %s", diff)
+			}
+		})
+	}
+}
+
+func TestLoadSearchDiagnostics(t *testing.T) {
+	path := t.TempDir()
+
+	testCases := []testCase{
+		{
+			"invalid variable default value",
+			`variable "example" {
+  type	= string
+  default = [1]
+}`,
+			fileName,
+			&search.Meta{
+				Path:      path,
+				Filenames: []string{fileName},
+				Variables: map[string]search.Variable{
+					"example": {
+						Type:         cty.String,
+						DefaultValue: cty.DynamicVal,
+					},
+				},
+				Lists:              map[string]search.List{},
+				ProviderReferences: map[search.ProviderRef]tfaddr.Provider{},
+			},
+			map[string]hcl.Diagnostics{
+				fileName: {
+					{
+						Severity: hcl.DiagError,
+						Summary:  `Invalid default value for variable`,
+						Detail:   `This default value is not compatible with the variable's type constraint: string required, but have tuple.`,
+						Subject: &hcl.Range{
+							Filename: fileName,
+							Start:    hcl.Pos{Line: 3, Column: 13, Byte: 49},
+							End:      hcl.Pos{Line: 3, Column: 16, Byte: 52},
+						},
+					},
+				},
+			},
+		},
+	}
+
+	runTestCases(testCases, t, path)
+}
+
+func compareVersionConstraint(x, y *version.Constraint) bool {
+	return x.Equals(y)
+}

earlydecoder/search/load_search.go

@@ -0,0 +1,139 @@
+// Copyright (c) HashiCorp, Inc.
+// SPDX-License-Identifier: MPL-2.0
+
+package earlydecoder
+
+import (
+	"fmt"
+
+	"github.com/hashicorp/hcl/v2"
+	"github.com/hashicorp/hcl/v2/ext/typeexpr"
+	"github.com/hashicorp/hcl/v2/gohcl"
+	"github.com/hashicorp/terraform-schema/search"
+	"github.com/zclconf/go-cty/cty"
+	"github.com/zclconf/go-cty/cty/convert"
+)
+
+type providerConfig struct {
+	Name  string
+	Alias string
+}
+
+type decodedSearch struct {
+	List            map[string]*search.List
+	Variables       map[string]*search.Variable
+	ProviderConfigs map[string]*providerConfig
+}
+
+var providerConfigSchema = &hcl.BodySchema{
+	Attributes: []hcl.AttributeSchema{
+		{
+			Name: "version",
+		},
+		{
+			Name: "alias",
+		},
+	},
+}
+
+func newDecodedSearch() *decodedSearch {
+	return &decodedSearch{
+		List:            make(map[string]*search.List),
+		Variables:       make(map[string]*search.Variable),
+		ProviderConfigs: make(map[string]*providerConfig),
+	}
+}
+
+func loadSearchFromFile(file *hcl.File, ds *decodedSearch) hcl.Diagnostics {
+	var diags hcl.Diagnostics
+
+	content, _, contentDiags := file.Body.PartialContent(rootSchema)
+	diags = append(diags, contentDiags...)
+
+	for _, block := range content.Blocks {
+		switch block.Type {
+		case "variable":
+			content, _, contentDiags := block.Body.PartialContent(variableSchema)
+			diags = append(diags, contentDiags...)
+
+			if len(block.Labels) != 1 || block.Labels[0] == "" {
+				continue
+			}
+
+			name := block.Labels[0]
+			description := ""
+			isSensitive := false
+			var valDiags hcl.Diagnostics
+
+			if attr, defined := content.Attributes["description"]; defined {
+				valDiags = gohcl.DecodeExpression(attr.Expr, nil, &description)
+				diags = append(diags, valDiags...)
+			}
+
+			if attr, defined := content.Attributes["sensitive"]; defined {
+				valDiags = gohcl.DecodeExpression(attr.Expr, nil, &isSensitive)
+				diags = append(diags, valDiags...)
+			}
+
+			varType := cty.DynamicPseudoType
+			var defaults *typeexpr.Defaults
+			if attr, defined := content.Attributes["type"]; defined {
+				varType, defaults, valDiags = typeexpr.TypeConstraintWithDefaults(attr.Expr)
+				diags = append(diags, valDiags...)
+			}
+
+			defaultValue := cty.NilVal
+			if attr, defined := content.Attributes["default"]; defined {
+				val, vDiags := attr.Expr.Value(nil)
+				diags = append(diags, vDiags...)
+				if !vDiags.HasErrors() {
+					if varType != cty.NilType {
+						var err error
+						val, err = convert.Convert(val, varType)
+						if err != nil {
+							diags = append(diags, &hcl.Diagnostic{
+								Severity: hcl.DiagError,
+								Summary:  "Invalid default value for variable",
+								Detail:   fmt.Sprintf("This default value is not compatible with the variable's type constraint: %s.", err),
+								Subject:  attr.Expr.Range().Ptr(),
+							})
+							val = cty.DynamicVal
+						}
+					}
+
+					defaultValue = val
+				}
+			}
+
+			ds.Variables[name] = &search.Variable{
+				Type:         varType,
+				Description:  description,
+				DefaultValue: defaultValue,
+				TypeDefaults: defaults,
+				IsSensitive:  isSensitive,
+			}
+
+		case "provider":
+			content, _, contentDiags := block.Body.PartialContent(providerConfigSchema)
+			diags = append(diags, contentDiags...)
+			name := block.Labels[0]
+			providerKey := name
+			var alias string
+			if attr, defined := content.Attributes["alias"]; defined {
+				valDiags := gohcl.DecodeExpression(attr.Expr, nil, &alias)
+				diags = append(diags, valDiags...)
+				if !valDiags.HasErrors() && alias != "" {
+					providerKey = fmt.Sprintf("%s.%s", name, alias)
+				}
+			}
+
+			ds.ProviderConfigs[providerKey] = &providerConfig{
+				Name:  name,
+				Alias: alias,
+			}
+		}
+
+	}
+
+	return diags
+}