represent list as a resource

Author: dsa0x

internal/addrs/resource.go

@@ -511,6 +511,10 @@ const (
 	// EphemeralResourceMode indicates an ephemeral resource, as defined by
 	// "ephemeral" blocks in configuration.
 	EphemeralResourceMode ResourceMode = 'E'
+
+	// ListResourceMode indicates a list resource, as defined by
+	// "list" blocks in tfquery configuration.
+	ListResourceMode ResourceMode = 'L'
 )
 
 // AbsResourceInstanceObject represents one of the specific remote objects

internal/configs/module.go

@@ -49,6 +49,7 @@ type Module struct {
 	ManagedResources   map[string]*Resource
 	DataResources      map[string]*Resource
 	EphemeralResources map[string]*Resource
+	ListResources      map[string]*Resource
 
 	Moved   []*Moved
 	Removed []*Removed
@@ -57,8 +58,6 @@ type Module struct {
 	Checks map[string]*Check
 
 	Tests map[string]*TestFile
-
-	Lists map[string]*List
 }
 
 // File describes the contents of a single configuration file.
@@ -130,10 +129,10 @@ func NewModule(primaryFiles, overrideFiles []*File) (*Module, hcl.Diagnostics) {
 		ManagedResources:   map[string]*Resource{},
 		EphemeralResources: map[string]*Resource{},
 		DataResources:      map[string]*Resource{},
+		ListResources:      map[string]*Resource{},
 		Checks:             map[string]*Check{},
 		ProviderMetas:      map[addrs.Provider]*ProviderMeta{},
 		Tests:              map[string]*TestFile{},
-		Lists:              map[string]*List{},
 	}
 
 	// Process the required_providers blocks first, to ensure that all
@@ -200,6 +199,8 @@ func (m *Module) ResourceByAddr(addr addrs.Resource) *Resource {
 		return m.DataResources[key]
 	case addrs.EphemeralResourceMode:
 		return m.EphemeralResources[key]
+	case addrs.ListResourceMode:
+		return m.ListResources[key]
 	default:
 		return nil
 	}
@@ -547,9 +548,9 @@ func (m *Module) appendQueryFile(file *QueryFile) hcl.Diagnostics {
 		m.Locals[l.Name] = l
 	}
 
-	for _, ql := range file.Lists {
+	for _, ql := range file.ListResources {
 		key := ql.moduleUniqueKey()
-		if existing, exists := m.Lists[key]; exists {
+		if existing, exists := m.ListResources[key]; exists {
 			diags = append(diags, &hcl.Diagnostic{
 				Severity: hcl.DiagError,
 				Summary:  fmt.Sprintf("Duplicate list %q configuration", existing.Type),
@@ -559,7 +560,7 @@ func (m *Module) appendQueryFile(file *QueryFile) hcl.Diagnostics {
 			continue
 		}
 		// set the provider FQN for the resource
-		m.Lists[key] = ql
+		m.ListResources[key] = ql
 		ql.Provider = m.ProviderForLocalConfig(ql.ProviderConfigAddr())
 	}
 

internal/configs/parser_config_dir_test.go

@@ -149,6 +149,61 @@ func TestParserLoadConfigDirWithTests(t *testing.T) {
 	}
 }
 
+func TestParserLoadConfigDirWithQueries(t *testing.T) {
+	tests := []struct {
+		name        string
+		directory   string
+		shouldFail  bool
+		diagnostics []string
+		resources   int
+	}{
+		{
+			name:      "simple",
+			directory: "testdata/query-files/valid/simple",
+			resources: 2,
+		},
+		{
+			name:       "no-provider",
+			directory:  "testdata/query-files/invalid/no-provider",
+			shouldFail: true,
+			diagnostics: []string{
+				"testdata/query-files/invalid/no-provider/main.tfquery.hcl:1,1-27: Missing \"provider\" attribute; You must specify a provider attribute when defining a list block.",
+			},
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			parser := NewParser(nil)
+			mod, diags := parser.LoadConfigDir(test.directory, MatchQueryFiles())
+			if test.shouldFail {
+				if !diags.HasErrors() {
+					t.Errorf("expected errors, but found none")
+				}
+				if len(diags) != len(test.diagnostics) {
+					t.Fatalf("expected %d errors, but found %d", len(test.diagnostics), len(diags))
+				}
+				for i, diag := range diags {
+					if diag.Error() != test.diagnostics[i] {
+						t.Errorf("expected error to be %q, but found %q", test.diagnostics[i], diag.Error())
+					}
+				}
+			} else {
+				if len(diags) > 0 { // We don't want any warnings or errors.
+					t.Errorf("unexpected diagnostics")
+					for _, diag := range diags {
+						t.Logf("- %s", diag)
+					}
+				}
+			}
+
+			if len(mod.ListResources) != test.resources {
+				t.Errorf("incorrect number of list blocks found: %d", len(mod.ListResources))
+			}
+		})
+	}
+}
+
 func TestParserLoadTestFiles_Invalid(t *testing.T) {
 
 	tcs := map[string][]string{

internal/configs/query_file.go

@@ -18,86 +18,36 @@ import (
 type QueryFile struct {
 	// Providers defines a set of providers that are available to the list blocks
 	// within this query file.
-	Providers map[string]*Provider
-
+	Providers       map[string]*Provider
 	ProviderConfigs []*Provider
 
-	Locals []*Local
-
+	Locals    []*Local
 	Variables []*Variable
 
-	// Lists defines the list of List blocks within the query file.
-	Lists []*List
+	// ListResources is a slice of List blocks within the query file.
+	ListResources []*Resource
 
 	VariablesDeclRange hcl.Range
 }
 
-// List represents a single list block within a query file.
-//
-// Each list block represents a single Terraform command to be executed and a set
-// of validations to list after the command.
-type List struct {
-	Type string
-	Name string
-
-	ProviderConfigRef *ProviderConfigRef
-	Provider          addrs.Provider
-
-	// File is a reference to the parent QueryFile that contains this block.
-	File *QueryFile
-
-	// Config is the main configuration body for the list block.
-	Config hcl.Body
-
-	TypeDeclRange   hcl.Range
-	ConfigDeclRange hcl.Range
-	DeclRange       hcl.Range
-}
-
-func (list *List) moduleUniqueKey() string {
-	return list.Name
-}
-
-func (list *List) Addr() addrs.List {
-	return addrs.List{
-		Type: list.Type,
-		Name: list.Name,
-	}
-}
-
-// ProviderConfigAddr returns the address for the provider configuration that
-// should be used for this list. This function returns a default provider
-// config addr if an explicit "provider" argument was not provided.
-func (list *List) ProviderConfigAddr() addrs.LocalProviderConfig {
-	if list.ProviderConfigRef == nil {
-		// all lists must have a provider config ref
-		panic("ProviderConfigRef is nil")
-	}
-
-	return addrs.LocalProviderConfig{
-		LocalName: list.ProviderConfigRef.Name,
-		Alias:     list.ProviderConfigRef.Alias,
-	}
-}
-
 func loadQueryFile(body hcl.Body) (*QueryFile, hcl.Diagnostics) {
 	var diags hcl.Diagnostics
 	file := &QueryFile{
 		Providers: make(map[string]*Provider),
 	}
 
-	content, contentDiags := body.Content(testQueryFileSchema)
+	content, contentDiags := body.Content(queryFileSchema)
 	diags = append(diags, contentDiags...)
 
 	listBlockNames := make(map[string]hcl.Range)
 
 	for _, block := range content.Blocks {
 		switch block.Type {
 		case "list":
-			list, listDiags := decodeQueryListBlock(block, file)
+			list, listDiags := decodeQueryListBlock(block)
 			diags = append(diags, listDiags...)
 			if !listDiags.HasErrors() {
-				file.Lists = append(file.Lists, list)
+				file.ListResources = append(file.ListResources, list)
 			}
 
 			if rng, exists := listBlockNames[list.Name]; exists {
@@ -140,21 +90,19 @@ func loadQueryFile(body hcl.Body) (*QueryFile, hcl.Diagnostics) {
 	return file, diags
 }
 
-func decodeQueryListBlock(block *hcl.Block, file *QueryFile) (*List, hcl.Diagnostics) {
+func decodeQueryListBlock(block *hcl.Block) (*Resource, hcl.Diagnostics) {
 	var diags hcl.Diagnostics
 
-	content, remain, contentDiags := block.Body.PartialContent(&hcl.BodySchema{
-		Attributes: []hcl.AttributeSchema{{Name: "provider"}},
-	})
+	content, remain, contentDiags := block.Body.PartialContent(QueryListResourceBlockSchema)
 	diags = append(diags, contentDiags...)
 
-	r := List{
-		File:          file,
-		Type:          block.Labels[0],
-		TypeDeclRange: block.LabelRanges[0],
-		Name:          block.Labels[1],
-		DeclRange:     block.DefRange,
-		Config:        remain,
+	r := Resource{
+		Mode:      addrs.ListResourceMode,
+		Type:      block.Labels[0],
+		TypeRange: block.LabelRanges[0],
+		Name:      block.Labels[1],
+		DeclRange: block.DefRange,
+		Config:    remain,
 	}
 
 	if attr, exists := content.Attributes["provider"]; exists {
@@ -180,10 +128,37 @@ func decodeQueryListBlock(block *hcl.Block, file *QueryFile) (*List, hcl.Diagnos
 			Subject:  r.DeclRange.Ptr(),
 		})
 	}
+
+	if attr, exists := content.Attributes["count"]; exists {
+		r.Count = attr.Expr
+	}
+
+	if attr, exists := content.Attributes["for_each"]; exists {
+		r.ForEach = attr.Expr
+		// Cannot have count and for_each on the same resource block
+		if r.Count != nil {
+			diags = append(diags, &hcl.Diagnostic{
+				Severity: hcl.DiagError,
+				Summary:  `Invalid combination of "count" and "for_each"`,
+				Detail:   `The "count" and "for_each" meta-arguments are mutually-exclusive.`,
+				Subject:  &attr.NameRange,
+			})
+		}
+	}
+
 	return &r, diags
 }
 
-var testQueryFileSchema = &hcl.BodySchema{
+// QueryListResourceBlockSchema is the schema for a list resource type within
+// a terraform query file.
+var QueryListResourceBlockSchema = &hcl.BodySchema{
+	Attributes: commonResourceAttributes,
+}
+
+// queryFileSchema is the schema for a terraform query file. It defines the
+// expected structure of the file, including the types of supported blocks and their
+// attributes.
+var queryFileSchema = &hcl.BodySchema{
 	Blocks: []hcl.BlockHeaderSchema{
 		{
 			Type:       "list",

internal/configs/testdata/query-files/invalid/no-provider/main.tfquery.hcl

@@ -0,0 +1,6 @@
+list "aws_instance" "test" {
+  count = 1
+  tags = {
+    Name = "test"
+  }
+}

internal/configs/testdata/query-files/valid/simple/main.tfquery.hcl

@@ -0,0 +1,14 @@
+list "aws_instance" "test" {
+  provider = aws
+  count = 1
+  tags = {
+    Name = "test"
+  }
+}
+list "aws_instance" "test2" {
+  provider = aws
+  count = 1
+  tags = {
+    Name = "test2"
+  }
+}