handle importing arbitrary resource data

Author: Emyrk

attr.go

@@ -77,11 +77,18 @@ func (a *expectedAttribute) string() string {
 }
 
 func (a *expectedAttribute) expectedTypeError(attr *terraform.Attribute, expectedType string) {
+	var fn string
+	if attr.IsNil() || attr.Type().Equals(cty.NilType) {
+		fn = "nil"
+	} else {
+		fn = attr.Type().FriendlyName()
+	}
+
 	a.error(hcl.Diagnostics{
 		{
 			Severity:   hcl.DiagError,
 			Summary:    "Invalid attribute type",
-			Detail:     fmt.Sprintf("The attribute %q must be of type %q, found type %q", attr.Name(), expectedType, attr.Type().FriendlyName()),
+			Detail:     fmt.Sprintf("The attribute %q must be of type %q, found type %q", attr.Name(), expectedType, fn),
 			Subject:    &attr.HCLAttribute().Range,
 			Context:    &a.p.block.HCLBlock().DefRange,
 			Expression: attr.HCLAttribute().Expr,

cli/clidisplay/resources.go

@@ -5,9 +5,11 @@ import (
 	"io"
 	"strings"
 
-	"github.com/coder/preview/types"
 	"github.com/hashicorp/hcl/v2"
 	"github.com/jedib0t/go-pretty/v6/table"
+	"github.com/zclconf/go-cty/cty"
+
+	"github.com/coder/preview/types"
 )
 
 func WorkspaceTags(writer io.Writer, tags types.TagBlocks) hcl.Diagnostics {
@@ -63,12 +65,14 @@ func Parameters(writer io.Writer, params []types.Parameter) {
 			strVal = "null"
 		} else if !p.Value.Value.IsKnown() {
 			strVal = "unknown"
-		} else {
+		} else if value.Type().Equals(cty.String) {
 			strVal = value.AsString()
+		} else {
+			strVal = value.GoString()
 		}
 
 		tableWriter.AppendRow(table.Row{
-			fmt.Sprintf("%s: %s\n%s", p.Name, p.Description, formatOptions(strVal, p.Options)),
+			fmt.Sprintf("%s (%s): %s\n%s", p.Name, p.BlockName, p.Description, formatOptions(strVal, p.Options)),
 		})
 		tableWriter.AppendSeparator()
 	}
@@ -79,6 +83,7 @@ func formatOptions(selected string, options []*types.RichParameterOption) string
 	var str strings.Builder
 	sep := ""
 	found := false
+
 	for _, opt := range options {
 		str.WriteString(sep)
 		prefix := "[ ]"

parameter.go

@@ -32,17 +32,29 @@ func RichParameters(modules terraform.Modules) ([]types.Parameter, hcl.Diagnosti
 
 			// Find the value of the parameter from the context.
 			paramValue := richParameterValue(block)
+			var defVal string
+
+			// default can be nil if the references are not resolved.
+			def := block.GetAttribute("default").Value()
+			if def.Equals(cty.NilVal).True() {
+				defVal = "<nil>"
+			} else if !def.IsKnown() {
+				defVal = "<unknown>"
+			} else {
+				defVal = p.attr("default").string()
+			}
 
 			param := types.Parameter{
 				Value: types.ParameterValue{
 					Value: paramValue,
 				},
 				RichParameter: types.RichParameter{
+					BlockName:    block.Labels()[1],
 					Name:         p.attr("name").required().string(),
 					Description:  p.attr("description").string(),
 					Type:         "",
 					Mutable:      false,
-					DefaultValue: p.attr("default").string(),
+					DefaultValue: defVal,
 					Icon:         p.attr("icon").string(),
 					Options:      paramOptions,
 					Validation:   nil,

plan.go

@@ -6,6 +6,7 @@ import (
 	"io"
 	"io/fs"
 	"log"
+	"reflect"
 	"strings"
 
 	"github.com/aquasecurity/trivy/pkg/iac/scanners/terraformplan/tfjson/parser"
@@ -45,11 +46,11 @@ func PlanJSONHook(dfs fs.FS, input Input) (func(ctx *tfcontext.Context, blocks t
 				continue
 			}
 
-			if parts[0] == "data" && !strings.Contains(resource.Type, "coder") {
+			if parts[0] != "data" || strings.Contains(parts[1], "coder") {
 				continue
 			}
 
-			val, err := attributeCtyVal(resource.AttributeValues)
+			val, err := toCtyValue(resource.AttributeValues)
 			if err != nil {
 				// TODO: Remove log
 				log.Printf("unable to determine value of resource %q: %v", resource.Address, err)
@@ -62,21 +63,49 @@ func PlanJSONHook(dfs fs.FS, input Input) (func(ctx *tfcontext.Context, blocks t
 	}, nil
 }
 
-func attributeCtyVal(attr map[string]interface{}) (cty.Value, error) {
-	mv := make(map[string]cty.Value)
-	for k, v := range attr {
-		ty, err := gocty.ImpliedType(v)
+func toCtyValue(a any) (cty.Value, error) {
+	if a == nil {
+		return cty.NilVal, nil
+	}
+	av := reflect.ValueOf(a)
+	switch av.Type().Kind() {
+	case reflect.Slice, reflect.Array:
+		sv := make([]cty.Value, 0, av.Len())
+		for i := 0; i < av.Len(); i++ {
+			v, err := toCtyValue(av.Index(i).Interface())
+			if err != nil {
+				return cty.NilVal, fmt.Errorf("slice value %d: %w", i, err)
+			}
+			sv = append(sv, v)
+		}
+		return cty.ListVal(sv), nil
+	case reflect.Map:
+		if av.Type().Key().Kind() != reflect.String {
+			return cty.NilVal, fmt.Errorf("map keys must be string, found %q", av.Type().Key().Kind())
+		}
+
+		mv := make(map[string]cty.Value)
+		var err error
+		for _, k := range av.MapKeys() {
+			v := av.MapIndex(k)
+			mv[k.String()], err = toCtyValue(v.Interface())
+			if err != nil {
+				return cty.NilVal, fmt.Errorf("map value %q: %w", k.String(), err)
+			}
+		}
+		return cty.ObjectVal(mv), nil
+	default:
+		ty, err := gocty.ImpliedType(a)
 		if err != nil {
-			return cty.NilVal, fmt.Errorf("implied type for %q: %w", k, err)
+			return cty.NilVal, fmt.Errorf("implied type: %w", err)
 		}
 
-		mv[k], err = gocty.ToCtyValue(v, ty)
+		cv, err := gocty.ToCtyValue(a, ty)
 		if err != nil {
-			return cty.NilVal, fmt.Errorf("implied value for %q: %w", k, err)
+			return cty.NilVal, fmt.Errorf("implied value: %w", err)
 		}
+		return cv, nil
 	}
-
-	return cty.ObjectVal(mv), nil
 }
 
 // ParsePlanJSON can parse the JSON output of a Terraform plan.

preview_test.go

@@ -10,11 +10,18 @@ import (
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"github.com/zclconf/go-cty/cty"
+	"github.com/zclconf/go-cty/cty/gocty"
 
 	"github.com/coder/preview"
 	"github.com/coder/preview/types"
 )
 
+func TestFoo(t *testing.T) {
+	ty, err := gocty.ImpliedType([]any{1, 2, 3})
+	require.NoError(t, err)
+	fmt.Println(ty.FriendlyName())
+}
+
 func Test_Extract(t *testing.T) {
 	t.Parallel()
 
@@ -145,6 +152,17 @@ func Test_Extract(t *testing.T) {
 			},
 			params: map[string]func(t *testing.T, parameter types.Parameter){},
 		},
+		{
+			name:    "aws instance list",
+			dir:     "instancelist",
+			expTags: map[string]string{},
+			input: preview.Input{
+				PlanJSONPath:    "before.json",
+				ParameterValues: map[string]types.ParameterValue{},
+			},
+			expUnknowns: []string{},
+			params:      map[string]func(t *testing.T, parameter types.Parameter){},
+		},
 	} {
 		t.Run(tc.name, func(t *testing.T) {
 			t.Parallel()

types/parameter.go

@@ -31,6 +31,9 @@ type RichParameter struct {
 	DisplayName string `json:"display_name"`
 	Order       int32  `json:"order"`
 	Ephemeral   bool   `json:"ephemeral"`
+
+	// HCL props
+	BlockName string `json:"block_name"`
 }
 
 type ParameterValidation struct {