Add config.Resource.OverrideScalarFieldType

pkg/config/common.go

@@ -5,6 +5,7 @@
 package config
 
 import (
+	"go/types"
 	"strings"
 
 	fwresource "github.com/hashicorp/terraform-plugin-framework/resource"
@@ -95,6 +96,7 @@ func DefaultResource(name string, terraformSchema *schema.Resource, terraformPlu
 		Conversions:                      []conversion.Conversion{conversion.NewIdentityConversionExpandPaths(conversion.AllVersions, conversion.AllVersions, nil)},
 		OverrideFieldNames:               map[string]string{},
 		listConversionPaths:              make(map[string]string),
+		overrideGeneratedFieldType:       map[string]types.Type{},
 	}
 	for _, f := range opts {
 		f(r)

pkg/config/resource.go

@@ -7,6 +7,7 @@ package config
 import (
 	"context"
 	"fmt"
+	"go/types"
 	"strings"
 	"time"
 
@@ -707,6 +708,11 @@ type Resource struct {
 	// the Terraform Plugin SDKv2 client.
 	useTerraformPluginFrameworkClient bool
 
+	// overrideGeneratedFieldType allows to manually override the type for the
+	// generated field of a Resource at the specified Terraform path.
+	// We only support type overrides for scalar fields currently.
+	overrideGeneratedFieldType map[string]types.Type
+
 	// OverrideFieldNames allows to manually override the relevant field name to
 	// avoid possible Go struct name conflicts that may occur after Multiversion
 	// CRDs support. During field generation, there may be fields with the same
@@ -1180,6 +1186,33 @@ func (r *Resource) RemoveSingletonListConversion(tfPath string) bool {
 	return false
 }
 
+// OverrideScalarFieldType allows to manually override the type for the
+// generated scalar field of a Resource at the specified Terraform path.
+// The path is a Terraform field path without the wildcard segments, e.g.,
+// "x.y", even if "x" is a collection type.
+// We only support overriding types for scalar fields as of now.
+// Trying to override the type generated for a non-scalar path will result in
+// a generation-time error.
+func (r *Resource) OverrideScalarFieldType(path string, t types.Type) {
+	r.overrideGeneratedFieldType[path] = t
+}
+
+// FieldTypeOverrideConfiguration represents a configuration for a set of type
+// overrides at a specific Terraform path.
+type FieldTypeOverrideConfiguration struct {
+	ParameterTypeOverride types.Type
+}
+
+// FieldTypeOverride returns the type override configuration for the specified
+// path. The path is a Terraform field path without the wildcard segments,
+// e.g., "x.y", even if "x" is a collection type.
+// Note: This accessor is meant to be only used by the code generator.
+func (r *Resource) FieldTypeOverride(path string) FieldTypeOverrideConfiguration {
+	return FieldTypeOverrideConfiguration{
+		ParameterTypeOverride: r.overrideGeneratedFieldType[path],
+	}
+}
+
 // SetEmbeddedObject sets the EmbeddedObject for the specified key.
 // The key is a Terraform field path without the wildcard segments.
 func (m SchemaElementOptions) SetEmbeddedObject(el string) {

pkg/config/resource_test.go

@@ -7,6 +7,7 @@ package config
 import (
 	"context"
 	"fmt"
+	"go/types"
 	"testing"
 
 	"github.com/crossplane/crossplane-runtime/v2/pkg/errors"
@@ -296,3 +297,80 @@ func TestRemoveSingletonListConversion(t *testing.T) {
 		})
 	}
 }
+
+func TestFieldTypeOverride(t *testing.T) {
+	strType := types.Typ[types.String]
+	type args struct {
+		r    func() *Resource
+		path string
+	}
+	type want struct {
+		// parameterType is the expected ParameterTypeOverride.String(), or the
+		// empty string when no usable override is expected for the path.
+		parameterType string
+	}
+	cases := map[string]struct {
+		reason string
+		args
+		want
+	}{
+		"OverrideConfigured": {
+			reason: "A scalar type override set for a path is returned for that path.",
+			args: args{
+				path: "x.y",
+				r: func() *Resource {
+					r := DefaultResource("test_resource", nil, nil, nil)
+					r.OverrideScalarFieldType("x.y", strType)
+					return r
+				},
+			},
+			want: want{parameterType: "string"},
+		},
+		"DifferentPath": {
+			reason: "A path without a configured override has no parameter type override.",
+			args: args{
+				path: "a.b",
+				r: func() *Resource {
+					r := DefaultResource("test_resource", nil, nil, nil)
+					r.OverrideScalarFieldType("x.y", strType)
+					return r
+				},
+			},
+			want: want{parameterType: ""},
+		},
+		"NoOverrides": {
+			reason: "A resource with no configured overrides has no parameter type override for any path.",
+			args: args{
+				path: "x.y",
+				r: func() *Resource {
+					return DefaultResource("test_resource", nil, nil, nil)
+				},
+			},
+			want: want{parameterType: ""},
+		},
+		"NilOverrideIgnored": {
+			reason: "A nil type override is indistinguishable from no override for the path.",
+			args: args{
+				path: "x.y",
+				r: func() *Resource {
+					r := DefaultResource("test_resource", nil, nil, nil)
+					r.OverrideScalarFieldType("x.y", nil)
+					return r
+				},
+			},
+			want: want{parameterType: ""},
+		},
+	}
+	for n, tc := range cases {
+		t.Run(n, func(t *testing.T) {
+			got := tc.args.r().FieldTypeOverride(tc.args.path).ParameterTypeOverride
+			gotStr := ""
+			if got != nil {
+				gotStr = got.String()
+			}
+			if diff := cmp.Diff(tc.want.parameterType, gotStr); diff != "" {
+				t.Errorf("%s\nFieldTypeOverride(%q): -want, +got:\n%s", tc.reason, tc.args.path, diff)
+			}
+		})
+	}
+}

pkg/types/builder.go

@@ -10,9 +10,9 @@ import (
 	"go/types"
 	"sort"
 
+	"github.com/crossplane/crossplane-runtime/v2/pkg/errors"
 	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
 	twtypes "github.com/muvaf/typewriter/pkg/types"
-	"github.com/pkg/errors"
 	"k8s.io/utils/ptr"
 
 	"github.com/crossplane/upjet/v2/pkg/config"
@@ -219,6 +219,17 @@ func (g *Builder) AddToBuilder(typeNames *TypeNames, r *resource) (*types.Named,
 }
 
 func (g *Builder) buildSchema(f *Field, cfg *config.Resource, names []string, cpath string, r *resource) (types.Type, types.Type, error) { //nolint:gocyclo
+	if o := cfg.FieldTypeOverride(cpath); o.ParameterTypeOverride != nil {
+		switch f.Schema.Type { //nolint:exhaustive // The default case handles the error cases (non-scalar paths) already.
+		case schema.TypeBool, schema.TypeFloat, schema.TypeInt, schema.TypeString:
+			return o.ParameterTypeOverride, nil, nil
+		default:
+			return nil, nil, errors.Errorf(
+				"field at path %q with Terraform type %s specified for OverrideScalarFieldType is not scalar, only scalar field types can be overridden",
+				cpath, f.Schema.Type.String())
+		}
+	}
+
 	switch f.Schema.Type {
 	case schema.TypeBool:
 		return types.NewPointer(types.Universe.Lookup("bool").Type()), nil, nil

pkg/types/builder_test.go

@@ -11,10 +11,10 @@ import (
 	"strings"
 	"testing"
 
+	"github.com/crossplane/crossplane-runtime/v2/pkg/errors"
 	"github.com/crossplane/crossplane-runtime/v2/pkg/test"
 	"github.com/google/go-cmp/cmp"
 	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
-	"github.com/pkg/errors"
 
 	"github.com/crossplane/upjet/v2/pkg/config"
 )
@@ -873,3 +873,95 @@ func TestBuild(t *testing.T) {
 		})
 	}
 }
+
+func TestBuildFieldTypeOverride(t *testing.T) {
+	type want struct {
+		forProvider  string
+		initProvider string
+		observation  string
+		errContains  string
+	}
+	cases := map[string]struct {
+		reason string
+		cfg    func() *config.Resource
+		want   want
+	}{
+		"ScalarOverrideAppliesToAllAPIs": {
+			reason: "Overriding a scalar field's type replaces it across forProvider, initProvider and observation.",
+			cfg: func() *config.Resource {
+				r := config.DefaultResource("test_resource", &schema.Resource{
+					Schema: map[string]*schema.Schema{
+						"enabled": {
+							Type:     schema.TypeBool,
+							Optional: true,
+						},
+					},
+				}, nil, nil)
+				r.Kind = ""
+				r.OverrideScalarFieldType("enabled", NewStringOrBoolType())
+				return r
+			},
+			want: want{
+				forProvider:  `type example.Parameters struct{Enabled *github.com/crossplane/upjet/v2/pkg/types.StringOrBool "json:\"enabled,omitempty\" tf:\"enabled,omitempty\""}`,
+				initProvider: `type example.InitParameters struct{Enabled *github.com/crossplane/upjet/v2/pkg/types.StringOrBool "json:\"enabled,omitempty\" tf:\"enabled,omitempty\""}`,
+				observation:  `type example.Observation struct{Enabled *github.com/crossplane/upjet/v2/pkg/types.StringOrBool "json:\"enabled,omitempty\" tf:\"enabled,omitempty\""}`,
+			},
+		},
+		"NonScalarOverrideErrors": {
+			reason: "Overriding a non-scalar (collection) field's type is a generation-time error.",
+			cfg: func() *config.Resource {
+				r := config.DefaultResource("test_resource", &schema.Resource{
+					Schema: map[string]*schema.Schema{
+						"settings": {
+							Type:     schema.TypeList,
+							Optional: true,
+							Elem: &schema.Resource{
+								Schema: map[string]*schema.Schema{
+									"size": {
+										Type:     schema.TypeInt,
+										Optional: true,
+									},
+								},
+							},
+						},
+					},
+				}, nil, nil)
+				r.Kind = ""
+				r.OverrideScalarFieldType("settings", NewStringOrBoolType())
+				return r
+			},
+			want: want{
+				errContains: `field at path "settings" with Terraform type TypeList specified for OverrideScalarFieldType is not scalar, only scalar field types can be overridden`,
+			},
+		},
+	}
+	for n, tc := range cases {
+		t.Run(n, func(t *testing.T) {
+			builder := NewBuilder(types.NewPackage("example", ""), CRDScopeCluster)
+			g, err := builder.Build(tc.cfg())
+
+			if tc.want.errContains != "" {
+				if err == nil {
+					t.Fatalf("%s\nBuild(...): expected an error containing %q, got nil", tc.reason, tc.want.errContains)
+				}
+				if !strings.Contains(err.Error(), tc.want.errContains) {
+					t.Errorf("%s\nBuild(...): error %q does not contain %q", tc.reason, err.Error(), tc.want.errContains)
+				}
+				return
+			}
+
+			if err != nil {
+				t.Fatalf("%s\nBuild(...): unexpected error: %v", tc.reason, err)
+			}
+			if diff := cmp.Diff(tc.want.forProvider, g.ForProviderType.Obj().String()); diff != "" {
+				t.Errorf("%s\nBuild(...): -want forProvider, +got forProvider:\n%s", tc.reason, diff)
+			}
+			if diff := cmp.Diff(tc.want.initProvider, g.InitProviderType.Obj().String()); diff != "" {
+				t.Errorf("%s\nBuild(...): -want initProvider, +got initProvider:\n%s", tc.reason, diff)
+			}
+			if diff := cmp.Diff(tc.want.observation, g.AtProviderType.Obj().String()); diff != "" {
+				t.Errorf("%s\nBuild(...): -want observation, +got observation:\n%s", tc.reason, diff)
+			}
+		})
+	}
+}

pkg/types/internal/string.go

@@ -0,0 +1,51 @@
+// SPDX-FileCopyrightText: 2026 The Crossplane Authors <https://crossplane.io>
+//
+// SPDX-License-Identifier: Apache-2.0
+
+package internal
+
+import (
+	"encoding/json"
+	"fmt"
+
+	"github.com/crossplane/crossplane-runtime/v2/pkg/errors"
+)
+
+const (
+	errInvalidValue = "value must be a JSON string or %T, got %s"
+)
+
+// Primitive is a type constraint that represents the supported primitive types
+// for StringOrPrimitive.
+type Primitive interface {
+	~bool |
+		~int | ~int8 | ~int16 | ~int32 | ~int64 |
+		~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64
+}
+
+// StringOrPrimitive is stored canonically as a string, but can decode
+// from other primitive values such as ints and bools.
+type StringOrPrimitive[T Primitive] string
+
+func (b *StringOrPrimitive[T]) UnmarshalJSON(data []byte) error {
+	// first try as a string value.
+	var s string
+	if err := json.Unmarshal(data, &s); err == nil {
+		*b = StringOrPrimitive[T](s)
+		return nil
+	}
+
+	// if not a string value, try as a value of the specified type parameter.
+	var v T
+	if err := json.Unmarshal(data, &v); err == nil {
+		*b = StringOrPrimitive[T](fmt.Sprint(v))
+		return nil
+	}
+
+	return errors.Errorf(errInvalidValue, v, string(data))
+}
+
+func (b *StringOrPrimitive[T]) MarshalJSON() ([]byte, error) {
+	// Always write back as string in the new canonical format.
+	return json.Marshal(*b)
+}