Initial commit

Signed-off-by: Alper Rifat Ulucinar <ulucinar@users.noreply.github.com>

Author: ulucinar

pkg/config/common.go

@@ -91,6 +91,7 @@ func DefaultResource(name string, terraformSchema *schema.Resource, terraformPlu
 		UseAsync:                         true,
 		SchemaElementOptions:             make(SchemaElementOptions),
 		ServerSideApplyMergeStrategies:   make(ServerSideApplyMergeStrategies),
+		listConversionPaths:              make(map[string]string),
 	}
 	for _, f := range opts {
 		f(r)

pkg/config/resource.go

@@ -7,6 +7,7 @@ package config
 import (
 	"context"
 	"fmt"
+	"strings"
 	"time"
 
 	xpv1 "github.com/crossplane/crossplane-runtime/apis/common/v1"
@@ -435,6 +436,15 @@ type Resource struct {
 	// SchemaElementOption for configuring options for schema elements.
 	SchemaElementOptions SchemaElementOptions
 
+	// listConversionPaths is the mapping from the CRD fieldpaths to the
+	// corresponding Terraform fieldpaths of embedded objects that need to be
+	// converted into singleton lists (lists of at most one element) at runtime.
+	// Such fields are lists in the Terraform schema, however upjet generates
+	// them as nested objects, and we need to convert them back to lists
+	// at runtime before passing them to the Terraform stack and after reading
+	// the state from the Terraform stack.
+	listConversionPaths map[string]string
+
 	// TerraformConfigurationInjector allows a managed resource to inject
 	// configuration values in the Terraform configuration map obtained by
 	// deserializing its `spec.forProvider` value. Managed resources can
@@ -541,6 +551,42 @@ func (m SchemaElementOptions) AddToObservation(el string) bool {
 	return m[el] != nil && m[el].AddToObservation
 }
 
+// CRDListConversionPaths returns the Resource's runtime CRD list conversion
+// paths in fieldpath syntax.
+func (r *Resource) CRDListConversionPaths() []string {
+	l := make([]string, 0, len(r.listConversionPaths))
+	for k := range r.listConversionPaths {
+		l = append(l, k)
+	}
+	return l
+}
+
+// TFListConversionPaths returns the Resource's runtime Terraform list
+// conversion paths in fieldpath syntax.
+func (r *Resource) TFListConversionPaths() []string {
+	l := make([]string, 0, len(r.listConversionPaths))
+	for _, v := range r.listConversionPaths {
+		l = append(l, v)
+	}
+	return l
+}
+
+// AddSingletonListConversion configures the list at the specified CRD
+// field path and the specified Terraform field path as an embedded object.
+// crdPath is the field path expression for the CRD schema and tfPath is
+// the field path expression for the Terraform schema corresponding to the
+// singleton list to be converted to an embedded object.
+// At runtime, upjet will convert such objects back and forth
+// from/to singleton lists while communicating with the Terraform stack.
+// The specified fieldpath expression must be a wildcard expression such as
+// `conditions[*]` or a 0-indexed expression such as `conditions[0]`. Other
+// index values are not allowed as this function deals with singleton lists.
+func (r *Resource) AddSingletonListConversion(crdPath, tfPath string) {
+	r.SchemaElementOptions.SetEmbeddedObject(strings.ReplaceAll(
+		strings.ReplaceAll(crdPath, "[*]", ""), "[0]", ""))
+	r.listConversionPaths[crdPath] = tfPath
+}
+
 // SetEmbeddedObject sets the EmbeddedObject for the specified key.
 func (m SchemaElementOptions) SetEmbeddedObject(el string) {
 	if m[el] == nil {

pkg/controller/external_tfpluginsdk.go

@@ -7,6 +7,8 @@ package controller
 import (
 	"context"
 	"fmt"
+	"slices"
+	"sort"
 	"strings"
 	"time"
 
@@ -122,6 +124,47 @@ type terraformPluginSDKExternal struct {
 	opTracker      *AsyncTracker
 }
 
+func convert(params map[string]any, paths []string, toList bool) (map[string]any, error) {
+	pv := fieldpath.Pave(params)
+
+	if toList {
+		slices.Sort(paths)
+	} else {
+		sort.Slice(paths, func(i, j int) bool {
+			return paths[i] > paths[j]
+		})
+	}
+
+	for _, fp := range paths {
+		exp, err := pv.ExpandWildcards(fp)
+		if err != nil {
+			return nil, errors.Wrapf(err, "cannot expand wildcards for the field path expression %s", fp)
+		}
+		switch len(exp) {
+		case 0:
+			return params, nil
+		case 1:
+			v, err := pv.GetValue(exp[0])
+			if err != nil {
+				return nil, errors.Wrapf(err, "cannot get the value at the field path %s with the list mode set to %t", exp[0], toList)
+			}
+			switch {
+			case toList:
+				if err := pv.SetValue(exp[0], []any{v}); err != nil {
+					return nil, errors.Wrapf(err, "cannot set the singleton list's value at the field path %s", exp[0])
+				}
+			default:
+				if err := pv.SetValue(exp[0], v.([]any)[0]); err != nil {
+					return nil, errors.Wrapf(err, "cannot set the embedded object's value at the field path %s", exp[0])
+				}
+			}
+		default:
+			return nil, errors.Errorf("unexpected number of expansions (%d) for the wildcard field path expression %s", len(exp), fp)
+		}
+	}
+	return params, nil
+}
+
 func getExtendedParameters(ctx context.Context, tr resource.Terraformed, externalName string, config *config.Resource, ts terraform.Setup, initParamsMerged bool, kube client.Client) (map[string]any, error) {
 	params, err := tr.GetMergedParameters(initParamsMerged)
 	if err != nil {
@@ -155,7 +198,7 @@ func getExtendedParameters(ctx context.Context, tr resource.Terraformed, externa
 			params["tags_all"] = params["tags"]
 		}
 	}
-	return params, nil
+	return convert(params, config.CRDListConversionPaths(), true)
 }
 
 func (c *TerraformPluginSDKConnector) processParamsWithHCLParser(schemaMap map[string]*schema.Schema, params map[string]any) map[string]any {
@@ -255,6 +298,10 @@ func (c *TerraformPluginSDKConnector) Connect(ctx context.Context, mg xpresource
 		if err != nil {
 			return nil, errors.Wrap(err, "failed to get the observation")
 		}
+		tfState, err = convert(tfState, c.config.CRDListConversionPaths(), true)
+		if err != nil {
+			return nil, err
+		}
 		copyParams := len(tfState) == 0
 		if err = resource.GetSensitiveParameters(ctx, &APISecretClient{kube: c.kube}, tr, tfState, tr.GetConnectionDetailsMapping()); err != nil {
 			return nil, errors.Wrap(err, "cannot store sensitive parameters into tfState")
@@ -511,6 +558,10 @@ func (n *terraformPluginSDKExternal) Observe(ctx context.Context, mg xpresource.
 		}
 		mg.SetConditions(xpv1.Available())
 
+		stateValueMap, err = convert(stateValueMap, n.config.TFListConversionPaths(), false)
+		if err != nil {
+			return managed.ExternalObservation{}, err
+		}
 		buff, err := json.TFParser.Marshal(stateValueMap)
 		if err != nil {
 			return managed.ExternalObservation{}, errors.Wrap(err, "cannot marshal the attributes of the new state for late-initialization")
@@ -623,6 +674,10 @@ func (n *terraformPluginSDKExternal) Create(ctx context.Context, mg xpresource.M
 	if _, err := n.setExternalName(mg, stateValueMap); err != nil {
 		return managed.ExternalCreation{}, errors.Wrap(err, "failed to set the external-name of the managed resource during create")
 	}
+	stateValueMap, err = convert(stateValueMap, n.config.CRDListConversionPaths(), false)
+	if err != nil {
+		return managed.ExternalCreation{}, err
+	}
 	err = mg.(resource.Terraformed).SetObservation(stateValueMap)
 	if err != nil {
 		return managed.ExternalCreation{}, errors.Errorf("could not set observation: %v", err)