Schema representation of list block config and results (#37209)

Author: dsa0x

internal/addrs/parse_target.go

@@ -177,6 +177,9 @@ func parseResourceInstanceUnderModule(moduleAddr ModuleInstance, allowPartial bo
 	case "ephemeral":
 		mode = EphemeralResourceMode
 		remain = remain[1:]
+	case "list":
+		mode = ListResourceMode
+		remain = remain[1:]
 	case "resource":
 		// Starting a resource address with "resource" is optional, so we'll
 		// just ignore it.

internal/configs/configschema/internal_validate.go

@@ -175,6 +175,10 @@ func (a *Attribute) internalValidate(name, prefix string) error {
 func (o *Object) InternalValidate() error {
 	var err error
 
+	if o.Nesting == nestingModeInvalid {
+		return fmt.Errorf("object schema nesting mode is invalid")
+	}
+
 	for name, attrS := range o.Attributes {
 		if attrS == nil {
 			err = errors.Join(err, fmt.Errorf("%s: attribute schema is nil", name))

internal/configs/configschema/internal_validate_test.go

@@ -333,7 +333,7 @@ func TestObjectInternalValidate(t *testing.T) {
 		Errs   []string
 	}{
 		"empty": {
-			&Object{},
+			&Object{Nesting: NestingSingle},
 			[]string{},
 		},
 		"valid": {

internal/plans/changes.go

@@ -56,6 +56,8 @@ func (c *Changes) Encode(schemas *schemarepo.Schemas) (*ChangesSrc, error) {
 			schema = p.ResourceTypes[rc.Addr.Resource.Resource.Type]
 		case addrs.DataResourceMode:
 			schema = p.DataSources[rc.Addr.Resource.Resource.Type]
+		case addrs.ListResourceMode:
+			schema = p.ListResourceTypes[rc.Addr.Resource.Resource.Type]
 		default:
 			panic(fmt.Sprintf("unexpected resource mode %s", rc.Addr.Resource.Resource.Mode))
 		}

internal/plans/changes_src.go

@@ -114,6 +114,8 @@ func (c *ChangesSrc) Decode(schemas *schemarepo.Schemas) (*Changes, error) {
 			schema = p.ResourceTypes[rcs.Addr.Resource.Resource.Type]
 		case addrs.DataResourceMode:
 			schema = p.DataSources[rcs.Addr.Resource.Resource.Type]
+		case addrs.ListResourceMode:
+			schema = p.ListResourceTypes[rcs.Addr.Resource.Resource.Type]
 		default:
 			panic(fmt.Sprintf("unexpected resource mode %s", rcs.Addr.Resource.Resource.Mode))
 		}

internal/plugin/grpc_provider.go

@@ -21,6 +21,7 @@ import (
 	"google.golang.org/grpc/status"
 
 	"github.com/hashicorp/terraform/internal/addrs"
+	"github.com/hashicorp/terraform/internal/configs/configschema"
 	"github.com/hashicorp/terraform/internal/logging"
 	"github.com/hashicorp/terraform/internal/plugin/convert"
 	"github.com/hashicorp/terraform/internal/providers"
@@ -170,7 +171,24 @@ func (p *GRPCProvider) GetProviderSchema() providers.GetProviderSchemaResponse {
 	}
 
 	for name, list := range protoResp.ListResourceSchemas {
-		resp.ListResourceTypes[name] = convert.ProtoToProviderSchema(list, nil)
+		ret := convert.ProtoToProviderSchema(list, nil)
+		resp.ListResourceTypes[name] = providers.Schema{
+			Version: ret.Version,
+			Body: &configschema.Block{
+				Attributes: map[string]*configschema.Attribute{
+					"data": {
+						Type:     cty.DynamicPseudoType,
+						Computed: true,
+					},
+				},
+				BlockTypes: map[string]*configschema.NestedBlock{
+					"config": {
+						Block:   *ret.Body,
+						Nesting: configschema.NestingSingle,
+					},
+				},
+			},
+		}
 	}
 
 	if decls, err := convert.FunctionDeclsFromProto(protoResp.Functions); err == nil {
@@ -357,7 +375,8 @@ func (p *GRPCProvider) ValidateListResourceConfig(r providers.ValidateListResour
 		return resp
 	}
 
-	mp, err := msgpack.Marshal(r.Config, listResourceSchema.Body.ImpliedType())
+	configSchema := listResourceSchema.Body.BlockTypes["config"]
+	mp, err := msgpack.Marshal(r.Config, configSchema.ImpliedType())
 	if err != nil {
 		resp.Diagnostics = resp.Diagnostics.Append(err)
 		return resp
@@ -1274,7 +1293,8 @@ func (p *GRPCProvider) ListResource(r providers.ListResourceRequest) providers.L
 		return resp
 	}
 
-	mp, err := msgpack.Marshal(r.Config, listResourceSchema.Body.ImpliedType())
+	configSchema := listResourceSchema.Body.BlockTypes["config"]
+	mp, err := msgpack.Marshal(r.Config, configSchema.ImpliedType())
 	if err != nil {
 		resp.Diagnostics = resp.Diagnostics.Append(err)
 		return resp
@@ -1298,43 +1318,42 @@ func (p *GRPCProvider) ListResource(r providers.ListResourceRequest) providers.L
 		return resp
 	}
 
-	var results []providers.ListResourceEvent
+	resp.Result = cty.DynamicVal
+	results := make([]cty.Value, 0)
 	// Process the stream
 	for {
 		if int64(len(results)) >= r.Limit {
 			// If we have reached the limit, we stop receiving events
-			resp.Results = results
-			return resp
+			break
 		}
 
 		event, err := client.Recv()
 		if err == io.EOF {
 			// End of stream, we're done
-			resp.Results = results
-			return resp
+			break
 		}
 
 		if err != nil {
-			resp.Results = results
 			resp.Diagnostics = resp.Diagnostics.Append(err)
-			return resp
+			break
 		}
 
-		// Process the event
-		resourceEvent := providers.ListResourceEvent{
-			DisplayName: event.DisplayName,
-			Diagnostics: convert.ProtoToDiagnostics(event.Diagnostic),
+		obj := map[string]cty.Value{
+			"display_name": cty.StringVal(event.DisplayName),
+			"state":        cty.NullVal(resourceSchema.Body.ImpliedType()),
+			"identity":     cty.NullVal(resourceSchema.Identity.ImpliedType()),
 		}
+		resp.Diagnostics = resp.Diagnostics.Append(convert.ProtoToDiagnostics(event.Diagnostic))
 
 		// Handle identity data - it must be present
 		if event.Identity == nil || event.Identity.IdentityData == nil {
-			resourceEvent.Diagnostics = resourceEvent.Diagnostics.Append(fmt.Errorf("missing identity data in ListResource event for %s", r.TypeName))
+			resp.Diagnostics = resp.Diagnostics.Append(fmt.Errorf("missing identity data in ListResource event for %s", r.TypeName))
 		} else {
 			identityVal, err := decodeDynamicValue(event.Identity.IdentityData, resourceSchema.Identity.ImpliedType())
 			if err != nil {
-				resourceEvent.Diagnostics = resourceEvent.Diagnostics.Append(err)
+				resp.Diagnostics = resp.Diagnostics.Append(err)
 			} else {
-				resourceEvent.Identity = identityVal
+				obj["identity"] = identityVal
 			}
 		}
 
@@ -1343,14 +1362,26 @@ func (p *GRPCProvider) ListResource(r providers.ListResourceRequest) providers.L
 			// Use the ResourceTypes schema for the resource object
 			resourceObj, err := decodeDynamicValue(event.ResourceObject, resourceSchema.Body.ImpliedType())
 			if err != nil {
-				resourceEvent.Diagnostics = resourceEvent.Diagnostics.Append(err)
+				resp.Diagnostics = resp.Diagnostics.Append(err)
 			} else {
-				resourceEvent.ResourceObject = resourceObj
+				obj["state"] = resourceObj
 			}
 		}
 
-		results = append(results, resourceEvent)
+		if resp.Diagnostics.HasErrors() {
+			break
+		}
+
+		results = append(results, cty.ObjectVal(obj))
+
 	}
+
+	// The provider result of a list resource is always a list, but
+	// we will wrap that list in an object with a single attribute "data",
+	// so that we can differentiate between a list resource instance (list.aws_instance.test[index])
+	// and the elements of the result of a list resource instance (list.aws_instance.test.data[index])
+	resp.Result = cty.ObjectVal(map[string]cty.Value{"data": cty.TupleVal(results)})
+	return resp
 }
 
 func (p *GRPCProvider) ValidateStateStoreConfig(r providers.ValidateStateStoreConfigRequest) providers.ValidateStateStoreConfigResponse {