replace nested field SecretKeyReference GoType

In this patch, we post-process the `pkg/model.TypeDef` objects that are
constructed by the code generator for nested fields of type "structure".
This post-processing is used to replace the GoType of an Attr
representing a Secret field in a nested parent field.

For example, the AmazonMQ `Broker` resource has a `Spec.Users` top-level
field. This top-level field is of type `[]*User`. The `User` Go struct
type is constructed from a `pkg/model.TypeDef` object that describes the
struct's attributes. One of those struct attributes is called
`Password`, and we want to replace the Go type for this `Attr` from
`string` to `*ackv1alpha1.SecretKeyReference`. In order to do this Go
type replacement, we need to search through the TypeDef objects, looking
for the parent field TypeDef, then look through that TypeDef's Attr
collection for the Attr with the same name as our Field that has a
FieldConfig.IsSecret setting of `true`.

Issue aws-controllers-k8s/community#743

Author: jaypipes

pkg/generate/generator.go

@@ -399,12 +399,129 @@ func (g *Generator) GetTypeDefs() ([]*ackmodel.TypeDef, map[string]string, error
 	sort.Slice(tdefs, func(i, j int) bool {
 		return tdefs[i].Names.Camel < tdefs[j].Names.Camel
 	})
+	g.processNestedFieldTypeDefs(tdefs)
 	g.typeDefs = tdefs
 	g.typeImports = timports
 	g.typeRenames = trenames
 	return tdefs, timports, nil
 }
 
+// processNestedFieldTypeDefs updates the supplied TypeDef structs' if a nested
+// field has been configured with a type overriding FieldConfig -- such as
+// FieldConfig.IsSecret.
+func (g *Generator) processNestedFieldTypeDefs(
+	tdefs []*ackmodel.TypeDef,
+) {
+	crds, _ := g.GetCRDs()
+	for _, crd := range crds {
+		for fieldPath, field := range crd.Fields {
+			if !strings.Contains(fieldPath, ".") {
+				// top-level fields have already had their structure
+				// transformed during the CRD.AddSpecField and
+				// CRD.AddStatusField methods. All we need to do here is look
+				// at nested fields, which are identifiable as fields with
+				// field paths contains a dot (".")
+				continue
+			}
+			if field.FieldConfig == nil {
+				// Likewise, we don't need to transform any TypeDef if the
+				// nested field doesn't have a FieldConfig instructing us to
+				// treat this field differently.
+				continue
+			}
+			if field.FieldConfig.IsSecret {
+				// Find the TypeDef that was created for the *containing*
+				// secret field struct. For example, assume the nested field
+				// path `Users..Password`, we'd want to find the TypeDef that
+				// was created for the `Users` field's element type (which is a
+				// struct)
+				replaceSecretAttrGoType(crd, field, tdefs)
+			}
+		}
+	}
+}
+
+// replaceSecretAttrGoType replaces a nested field ackmodel.Attr's GoType with
+// `*ackv1alpha1.SecretKeyReference`.
+func replaceSecretAttrGoType(
+	crd *ackmodel.CRD,
+	field *ackmodel.Field,
+	tdefs []*ackmodel.TypeDef,
+) {
+	fieldPath := field.Path
+	parentFieldPath := ackmodel.ParentFieldPath(field.Path)
+	parentField, ok := crd.Fields[parentFieldPath]
+	if !ok {
+		msg := fmt.Sprintf(
+			"Cannot find parent field at parent path %s for %s",
+			parentFieldPath,
+			fieldPath,
+		)
+		panic(msg)
+	}
+	if parentField.ShapeRef == nil {
+		msg := fmt.Sprintf(
+			"parent field at parent path %s has a nil ShapeRef!",
+			parentFieldPath,
+		)
+		panic(msg)
+	}
+	parentFieldShape := parentField.ShapeRef.Shape
+	parentFieldShapeName := parentField.ShapeRef.ShapeName
+	parentFieldShapeType := parentFieldShape.Type
+	// For list and map types, we need to grab the element/value
+	// type, since that's the type def we need to modify.
+	if parentFieldShapeType == "list" {
+		if parentFieldShape.MemberRef.Shape.Type != "structure" {
+			msg := fmt.Sprintf(
+				"parent field at parent path %s is a list type with a non-structure element member shape %s!",
+				parentFieldPath,
+				parentFieldShape.MemberRef.Shape.Type,
+			)
+			panic(msg)
+		}
+		parentFieldShapeName = parentField.ShapeRef.Shape.MemberRef.ShapeName
+	} else if parentFieldShapeType == "map" {
+		if parentFieldShape.ValueRef.Shape.Type != "structure" {
+			msg := fmt.Sprintf(
+				"parent field at parent path %s is a map type with a non-structure value member shape %s!",
+				parentFieldPath,
+				parentFieldShape.ValueRef.Shape.Type,
+			)
+			panic(msg)
+		}
+		parentFieldShapeName = parentField.ShapeRef.Shape.ValueRef.ShapeName
+	}
+	var parentTypeDef *ackmodel.TypeDef
+	for _, tdef := range tdefs {
+		if tdef.Names.Original == parentFieldShapeName {
+			parentTypeDef = tdef
+		}
+	}
+	if parentTypeDef == nil {
+		msg := fmt.Sprintf(
+			"unable to find associated TypeDef for parent field "+
+				"at parent path %s!",
+			parentFieldPath,
+		)
+		panic(msg)
+	}
+	// Now we modify the parent type def's Attr that corresponds to
+	// the secret field...
+	attr, found := parentTypeDef.Attrs[field.Names.Camel]
+	if !found {
+		msg := fmt.Sprintf(
+			"unable to find attr %s in parent TypeDef %s "+
+				"at parent path %s!",
+			field.Names.Camel,
+			parentTypeDef.Names.Original,
+			parentFieldPath,
+		)
+		panic(msg)
+	}
+	attr.GoType = "*ackv1alpha1.SecretKeyReference"
+}
+
 // processNestedFields is responsible for walking all of the CRDs' Spec and
 // Status fields' Shape objects and adding `pkg/model.Field` objects for all
 // nested fields along with that `Field`'s `Config` object that allows us to
@@ -447,7 +564,6 @@ func (g *Generator) processNestedField(
 			g.processNestedMapField(crd, field.Path+"..", field)
 		}
 	}
-	// TODO(jaypipes): Handle Attribute-based fields...
 }
 
 // processNestedStructField recurses through the members of a nested field that

pkg/generate/mq_test.go

@@ -28,10 +28,7 @@ func TestMQ_Broker(t *testing.T) {
 
 	g := testutil.NewGeneratorForService(t, "mq")
 
-	crds, err := g.GetCRDs()
-	require.Nil(err)
-
-	crd := getCRDByName("Broker", crds)
+	crd := testutil.GetCRDByName(t, g, "Broker")
 	require.NotNil(crd)
 
 	// We want to verify that the `Password` field of the `Spec.Users` field
@@ -43,4 +40,14 @@ func TestMQ_Broker(t *testing.T) {
 	require.True(found)
 	require.NotNil(passField.FieldConfig)
 	assert.True(passField.FieldConfig.IsSecret)
+
+	// We now verify that the User TypeDef that is inferred by the code
+	// generator has had its Go type changed from `string` to
+	// `*ackv1alpha1.SecretKeyReference` as part of the nested fields
+	// post-processing of type defs in the GetTypeDefs() method.
+	tdef := testutil.GetTypeDefByName(t, g, "User")
+	require.NotNil(tdef)
+	passAttr, found := tdef.Attrs["Password"]
+	require.True(found)
+	assert.Equal("*ackv1alpha1.SecretKeyReference", passAttr.GoType)
 }

pkg/model/field.go

@@ -14,6 +14,8 @@
 package model
 
 import (
+	"strings"
+
 	ackgenconfig "github.com/aws-controllers-k8s/code-generator/pkg/generate/config"
 	"github.com/aws-controllers-k8s/code-generator/pkg/names"
 	"github.com/aws-controllers-k8s/code-generator/pkg/util"
@@ -61,6 +63,24 @@ func (f *Field) IsRequired() bool {
 	return util.InStrings(f.Names.ModelOriginal, f.CRD.Ops.Create.InputRef.Shape.Required)
 }
 
+// ParentFieldPath takes a field path and returns the field path of the
+// containing "parent" field. For example, if the field path
+// `Users..Credentials.Login` is passed in, this function returns
+// `Users..Credentials`. If `Users..Password` is supplied, this function
+// returns `Users`, etc.
+func ParentFieldPath(path string) string {
+	parts := strings.Split(path, ".")
+	// Pop the last element of the supplied field path
+	parts = parts[0 : len(parts)-1]
+	// If the parent field's type is a list or map, there will be two dots ".."
+	// in the supplied field path. We don't want the returned field path to end
+	// in a dot, since that would be invalid, so we trim it off here
+	if parts[len(parts)-1] == "" {
+		parts = parts[0 : len(parts)-1]
+	}
+	return strings.Join(parts, ".")
+}
+
 // NewField returns a pointer to a new Field object
 func NewField(
 	crd *CRD,

pkg/model/field_test.go

@@ -0,0 +1,37 @@
+package model_test
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+
+	"github.com/aws-controllers-k8s/code-generator/pkg/model"
+)
+
+func TestParentFieldPath(t *testing.T) {
+	assert := assert.New(t)
+	testCases := []struct {
+		subject string
+		want    string
+	}{
+		{
+			"Repository.Name",
+			"Repository",
+		},
+		{
+			"Users..Password",
+			"Users",
+		},
+		{
+			"User.Credentials..Password",
+			"User.Credentials",
+		},
+	}
+
+	for _, tc := range testCases {
+		result := model.ParentFieldPath(
+			tc.subject,
+		)
+		assert.Equal(tc.want, result)
+	}
+}

pkg/testutil/get.go

@@ -40,3 +40,22 @@ func GetCRDByName(
 	}
 	return nil
 }
+
+// GetTypeDefByName returns a TypeDef model with the supplied name
+func GetTypeDefByName(
+	t *testing.T,
+	g *generate.Generator,
+	name string,
+) *model.TypeDef {
+	require := require.New(t)
+
+	tdefs, _, err := g.GetTypeDefs()
+	require.Nil(err)
+
+	for _, tdef := range tdefs {
+		if tdef.Names.Original == name {
+			return tdef
+		}
+	}
+	return nil
+}