chore: support complex types in workspace tags

Author: Emyrk

preview_test.go

@@ -53,14 +53,16 @@ func Test_Extract(t *testing.T) {
 			name: "sometags",
 			dir:  "sometags",
 			expTags: map[string]string{
-				"string": "foo",
-				"number": "42",
-				"bool":   "true",
-				"extra":  "bar",
-			},
-			unknownTags: []string{
-				"map", "list", "null",
+				"string":  "foo",
+				"number":  "42",
+				"bool":    "true",
+				"extra":   "bar",
+				"list":    `["a", "b", "c"]`,
+				"map":     `{"key1": "value1", "key2": "value2"}`,
+				"complex": `{"nested": {"key": "value"}, "nested_list": [1, 2, 3]}`,
+				"null":    "null",
 			},
+			unknownTags: []string{},
 		},
 		{
 			name: "simple static values",
@@ -522,7 +524,18 @@ func Test_Extract(t *testing.T) {
 			// Assert tags
 			validTags := output.WorkspaceTags.Tags()
 
-			assert.Equal(t, tc.expTags, validTags)
+			for k, expected := range tc.expTags {
+				tag, ok := validTags[k]
+				if !ok {
+					t.Errorf("expected tag %q to be present in output, but it was not", k)
+					continue
+				}
+				if tag != expected {
+					assert.JSONEqf(t, expected, tag, "tag %q does not match expected, nor is it a json equivalent", k)
+				}
+			}
+			assert.Equal(t, len(tc.expTags), len(output.WorkspaceTags.Tags()), "unexpected number of tags in output")
+
 			assert.ElementsMatch(t, tc.unknownTags, output.WorkspaceTags.UnusableTags().SafeNames())
 
 			// Assert params

testdata/sometags/main.tf

@@ -17,6 +17,12 @@ data "coder_workspace_tags" "custom_workspace_tags" {
       "key1" = "value1"
       "key2" = "value2"
     }
+    "complex" = {
+      "nested_list" = [1, 2, 3]
+      "nested"  = {
+        "key" = "value"
+      }
+    }
     "null"  = null
   }
 }

workspacetags.go

@@ -6,6 +6,7 @@ import (
 	"github.com/aquasecurity/trivy/pkg/iac/terraform"
 	"github.com/hashicorp/hcl/v2"
 	"github.com/zclconf/go-cty/cty"
+	"github.com/zclconf/go-cty/cty/json"
 
 	"github.com/coder/preview/types"
 )
@@ -47,21 +48,6 @@ func workspaceTags(modules terraform.Modules, files map[string]*hcl.File) (types
 				continue
 			}
 
-			// tagsObj, ok := tagsAttr.HCLAttribute().Expr.(*hclsyntax.ObjectConsExpr)
-			// if !ok {
-			//	diags = diags.Append(&hcl.Diagnostic{
-			//		Severity: hcl.DiagError,
-			//		Summary:  "Incorrect type for \"tags\" attribute",
-			//		// TODO: better error message for types
-			//		Detail:      fmt.Sprintf(`"tags" attribute must be an 'ObjectConsExpr', but got %T`, tagsAttr.HCLAttribute().Expr),
-			//		Subject:     &tagsAttr.HCLAttribute().NameRange,
-			//		Context:     &tagsAttr.HCLAttribute().Range,
-			//		Expression:  tagsAttr.HCLAttribute().Expr,
-			//		EvalContext: block.Context().Inner(),
-			//	})
-			//	continue
-			//}
-
 			var tags []types.Tag
 			tagsValue.ForEachElement(func(key cty.Value, val cty.Value) (stop bool) {
 				r := tagsAttr.HCLAttribute().Expr.Range()
@@ -75,15 +61,7 @@ func workspaceTags(modules terraform.Modules, files map[string]*hcl.File) (types
 
 				return false
 			})
-			// for _, item := range tagsObj.Items {
-			//	tag, tagDiag := newTag(tagsObj, files, item, evCtx)
-			//	if tagDiag != nil {
-			//		diags = diags.Append(tagDiag)
-			//		continue
-			//	}
-			//
-			//	tags = append(tags, tag)
-			//}
+
 			tagBlocks = append(tagBlocks, types.TagBlock{
 				Tags:  tags,
 				Block: block,
@@ -96,73 +74,47 @@ func workspaceTags(modules terraform.Modules, files map[string]*hcl.File) (types
 
 // newTag creates a workspace tag from its hcl expression.
 func newTag(srcRange *hcl.Range, _ map[string]*hcl.File, key, val cty.Value) (types.Tag, *hcl.Diagnostic) {
-	// key, kdiags := expr.KeyExpr.Value(evCtx)
-	// val, vdiags := expr.ValueExpr.Value(evCtx)
-
-	// TODO: ???
-
-	// if kdiags.HasErrors() {
-	//	key = cty.UnknownVal(cty.String)
-	//}
-	// if vdiags.HasErrors() {
-	//	val = cty.UnknownVal(cty.String)
-	//}
-
 	if key.IsKnown() && key.Type() != cty.String {
 		return types.Tag{}, &hcl.Diagnostic{
 			Severity: hcl.DiagError,
 			Summary:  "Invalid key type for tags",
 			Detail:   fmt.Sprintf("Key must be a string, but got %s", key.Type().FriendlyName()),
-			//Subject:  &r,
-			Context: srcRange,
-			//Expression:  expr.KeyExpr,
-			//EvalContext: evCtx,
+			Context:  srcRange,
 		}
 	}
 
 	tag := types.Tag{
 		Key: types.HCLString{
 			Value: key,
-			//ValueDiags: kdiags,
-			//ValueExpr:  expr.KeyExpr,
 		},
 		Value: types.HCLString{
 			Value: val,
-			//ValueDiags: vdiags,
-			//ValueExpr:  expr.ValueExpr,
 		},
 	}
 
-	// If the value is known, but the type is not a string, bool, or number.
-	// Then throw an error. Only the supported types can safely be converted to a string.
-	if !(val.Type() == cty.String || val.Type() == cty.Bool || val.Type() == cty.Number) {
+	switch val.Type() {
+	case cty.String, cty.Bool, cty.Number:
+		// These types are supported and can be safely converted to a string.
+	default:
 		fr := "<nil>"
 		if !val.Type().Equals(cty.NilType) {
 			fr = val.Type().FriendlyName()
 		}
 
-		tag.Value.ValueDiags = tag.Value.ValueDiags.Append(&hcl.Diagnostic{
-			Severity: hcl.DiagError,
-			Summary:  fmt.Sprintf("Invalid value type for tag %q", tag.KeyString()),
-			Detail:   fmt.Sprintf("Value must be a string, but got %s", fr),
-			//Subject:     &r,
-			Context: srcRange,
-			//Expression:  expr.ValueExpr,
-			//EvalContext: evCtx,
-		})
+		// Unsupported types will be converted to a JSON string representation.
+		jsonData, err := json.Marshal(val, val.Type())
+		if err != nil {
+			tag.Value.ValueDiags = tag.Value.ValueDiags.Append(&hcl.Diagnostic{
+				Severity: hcl.DiagError,
+				Summary:  fmt.Sprintf("Invalid value type for tag %q", tag.KeyString()),
+				Detail:   fmt.Sprintf("Value must be a string, but got %s. Attempt to marshal to json: %s", fr, err.Error()),
+				Context:  srcRange,
+			})
+		} else {
+			// Value successfully marshaled to JSON, we can store it as a string.
+			tag.Value.Value = cty.StringVal(string(jsonData))
+		}
 	}
 
-	// ks, err := source(expr.KeyExpr.Range(), files)
-	// if err == nil {
-	//	src := string(ks)
-	//	tag.Key.Source = &src
-	//}
-	//
-	// vs, err := source(expr.ValueExpr.Range(), files)
-	// if err == nil {
-	//	src := string(vs)
-	//	tag.Value.Source = &src
-	//}
-
 	return tag, nil
 }