refactor(schema): remove unused custom types from SimpleSchema

This patch removes the `Types` field has been removed from the `Schema`
struct as it's currently not supported in KRO. This change include:

- Removing the `Types` field from the `v1alpha1.Schema` struct
- Making the transformer type and its methods private since they're package
  implementation details
- Adding a new public `ToOpenAPISpec` function for external usage

Author: a-hilaly

api/v1alpha1/resource_group.go

@@ -66,9 +66,6 @@ type Schema struct {
 	// that the resourcegroup is managing. This is adhering to the
 	// SimpleSchema spec.
 	Status runtime.RawExtension `json:"status,omitempty"`
-	// Types are custom types that are used to simplify the spec and
-	// status.
-	Types runtime.RawExtension `json:"types,omitempty"`
 	// Validation is a list of validation rules that are applied to the
 	// resourcegroup.
 	// Not implemented yet.

api/v1alpha1/zz_generated.deepcopy.go

@@ -119,12 +119,6 @@ spec:
                       SimpleSchema spec.
                     type: object
                     x-kubernetes-preserve-unknown-fields: true
-                  types:
-                    description: |-
-                      Types are custom types that are used to simplify the spec and
-                      status.
-                    type: object
-                    x-kubernetes-preserve-unknown-fields: true
                   validation:
                     description: |-
                       Validation is a list of validation rules that are applied to the

config/crd/bases/kro.run_resourcegroups.yaml

@@ -509,22 +509,16 @@ func (b *Builder) buildInstanceResource(
 // used to generate the CRD for the instance resource. The instance spec
 // schema is expected to be defined using the "SimpleSchema" format.
 func buildInstanceSpecSchema(rgSchema *v1alpha1.Schema) (*extv1.JSONSchemaProps, error) {
-	customTypes := map[string]interface{}{}
-	err := yaml.UnmarshalStrict(rgSchema.Types.Raw, &customTypes)
-	if err != nil {
-		return nil, fmt.Errorf("failed to unmarshal types schema: %w", err)
-	}
-
 	// We need to unmarshal the instance schema to a map[string]interface{} to
 	// make it easier to work with.
-	unstructuredInstance := map[string]interface{}{}
-	err = yaml.UnmarshalStrict(rgSchema.Spec.Raw, &unstructuredInstance)
+	instanceSpec := map[string]interface{}{}
+	err := yaml.UnmarshalStrict(rgSchema.Spec.Raw, &instanceSpec)
 	if err != nil {
 		return nil, fmt.Errorf("failed to unmarshal spec schema: %w", err)
 	}
 
 	// The instance resource has a schema defined using the "SimpleSchema" format.
-	instanceSchema, err := simpleschema.NewTransformer().BuildOpenAPISchema(unstructuredInstance)
+	instanceSchema, err := simpleschema.ToOpenAPISpec(instanceSpec)
 	if err != nil {
 		return nil, fmt.Errorf("failed to build OpenAPI schema for instance: %v", err)
 	}

internal/graph/builder.go

@@ -0,0 +1,34 @@
+// Copyright Amazon.com Inc. or its affiliates. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License"). You may
+// not use this file except in compliance with the License. A copy of the
+// License is located at
+//
+//	http://aws.amazon.com/apache2.0/
+//
+// or in the "license" file accompanying this file. This file is distributed
+// on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
+// express or implied. See the License for the specific language governing
+// permissions and limitations under the License.
+
+package simpleschema
+
+import (
+	"fmt"
+
+	extv1 "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1"
+)
+
+// ToOpenAPISpec converts a SimpleSchema object to an OpenAPI schema.
+//
+// The input object is a map[string]interface{} where the key is the field name
+// and the value is the field type.
+func ToOpenAPISpec(obj map[string]interface{}) (*extv1.JSONSchemaProps, error) {
+	tf := newTransformer()
+	return tf.buildOpenAPISchema(obj)
+}
+
+// FromOpenAPISpec converts an OpenAPI schema to a SimpleSchema object.
+func FromOpenAPISpec(schema *extv1.JSONSchemaProps) (map[string]interface{}, error) {
+	return nil, fmt.Errorf("not implemented")
+}

internal/simpleschema/simplerschema.go

@@ -19,24 +19,27 @@ import (
 	extv1 "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1"
 )
 
-// Transformer is a transformer for OpenAPI schemas
-type Transformer struct {
+// transformer is a transformer for OpenAPI schemas
+type transformer struct {
 	preDefinedTypes map[string]extv1.JSONSchemaProps
 }
 
-// NewTransformer creates a new transformer
-func NewTransformer() *Transformer {
-	return &Transformer{
+// newTransformer creates a new transformer
+func newTransformer() *transformer {
+	return &transformer{
 		preDefinedTypes: make(map[string]extv1.JSONSchemaProps),
 	}
 }
 
-// LoadPreDefinedTypes loads pre-defined types into the transformer.
+// loadPreDefinedTypes loads pre-defined types into the transformer.
 // The pre-defined types are used to resolve references in the schema.
-func (t *Transformer) LoadPreDefinedTypes(obj map[string]interface{}) error {
+//
+// As of today, KRO doesn't support custom types in the schema - do
+// not use this function.
+func (t *transformer) loadPreDefinedTypes(obj map[string]interface{}) error {
 	t.preDefinedTypes = make(map[string]extv1.JSONSchemaProps)
 
-	jsonSchemaProps, err := t.BuildOpenAPISchema(obj)
+	jsonSchemaProps, err := t.buildOpenAPISchema(obj)
 	if err != nil {
 		return fmt.Errorf("failed to build pre-defined types schema: %w", err)
 	}
@@ -47,9 +50,9 @@ func (t *Transformer) LoadPreDefinedTypes(obj map[string]interface{}) error {
 	return nil
 }
 
-// BuildOpenAPISchema builds an OpenAPI schema from the given object
+// buildOpenAPISchema builds an OpenAPI schema from the given object
 // of a SimpleSchema.
-func (tf *Transformer) BuildOpenAPISchema(obj map[string]interface{}) (*extv1.JSONSchemaProps, error) {
+func (tf *transformer) buildOpenAPISchema(obj map[string]interface{}) (*extv1.JSONSchemaProps, error) {
 	schema := &extv1.JSONSchemaProps{
 		Type:       "object",
 		Properties: map[string]extv1.JSONSchemaProps{},
@@ -65,25 +68,25 @@ func (tf *Transformer) BuildOpenAPISchema(obj map[string]interface{}) (*extv1.JS
 
 	return schema, nil
 }
-func (tf *Transformer) transformField(
+func (tf *transformer) transformField(
 	key string, value interface{},
 	// parentSchema is used to add the key to the required list
 	parentSchema *extv1.JSONSchemaProps,
 ) (*extv1.JSONSchemaProps, error) {
 	switch v := value.(type) {
 	case map[interface{}]interface{}:
 		nMap := transformMap(v)
-		return tf.BuildOpenAPISchema(nMap)
+		return tf.buildOpenAPISchema(nMap)
 	case map[string]interface{}:
-		return tf.BuildOpenAPISchema(v)
+		return tf.buildOpenAPISchema(v)
 	case string:
 		return tf.parseFieldSchema(key, v, parentSchema)
 	default:
 		return nil, fmt.Errorf("unknown type in schema: key: %s, value: %v", key, value)
 	}
 }
 
-func (tf *Transformer) parseFieldSchema(key, fieldValue string, parentSchema *extv1.JSONSchemaProps) (*extv1.JSONSchemaProps, error) {
+func (tf *transformer) parseFieldSchema(key, fieldValue string, parentSchema *extv1.JSONSchemaProps) (*extv1.JSONSchemaProps, error) {
 	fieldType, markers, err := parseFieldSchema(fieldValue)
 	if err != nil {
 		return nil, fmt.Errorf("failed to parse field schema for %s: %v", key, err)
@@ -117,7 +120,7 @@ func (tf *Transformer) parseFieldSchema(key, fieldValue string, parentSchema *ex
 	return fieldJSONSchemaProps, nil
 }
 
-func (tf *Transformer) handleMapType(key, fieldType string) (*extv1.JSONSchemaProps, error) {
+func (tf *transformer) handleMapType(key, fieldType string) (*extv1.JSONSchemaProps, error) {
 	keyType, valueType, err := parseMapType(fieldType)
 	if err != nil {
 		return nil, fmt.Errorf("failed to parse map type for %s: %w", key, err)
@@ -150,7 +153,7 @@ func (tf *Transformer) handleMapType(key, fieldType string) (*extv1.JSONSchemaPr
 	return fieldJSONSchemaProps, nil
 }
 
-func (tf *Transformer) handleSliceType(key, fieldType string) (*extv1.JSONSchemaProps, error) {
+func (tf *transformer) handleSliceType(key, fieldType string) (*extv1.JSONSchemaProps, error) {
 	elementType, err := parseSliceType(fieldType)
 	if err != nil {
 		return nil, fmt.Errorf("failed to parse slice type for %s: %w", key, err)
@@ -180,7 +183,7 @@ func (tf *Transformer) handleSliceType(key, fieldType string) (*extv1.JSONSchema
 	return fieldJSONSchemaProps, nil
 }
 
-func (tf *Transformer) applyMarkers(schema *extv1.JSONSchemaProps, markers []*Marker, key string, parentSchema *extv1.JSONSchemaProps) {
+func (tf *transformer) applyMarkers(schema *extv1.JSONSchemaProps, markers []*Marker, key string, parentSchema *extv1.JSONSchemaProps) {
 	for _, marker := range markers {
 		switch marker.MarkerType {
 		case MarkerTypeRequired:

internal/simpleschema/transform.go

@@ -21,10 +21,10 @@ import (
 )
 
 func TestBuildOpenAPISchema(t *testing.T) {
-	transformer := NewTransformer()
+	transformer := newTransformer()
 
 	// Load pre-defined types
-	err := transformer.LoadPreDefinedTypes(map[string]interface{}{
+	err := transformer.loadPreDefinedTypes(map[string]interface{}{
 		"Address": map[string]interface{}{
 			"street":  "string",
 			"city":    "string",
@@ -283,7 +283,7 @@ func TestBuildOpenAPISchema(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			got, err := transformer.BuildOpenAPISchema(tt.obj)
+			got, err := transformer.buildOpenAPISchema(tt.obj)
 			if (err != nil) != tt.wantErr {
 				t.Errorf("BuildOpenAPISchema() error = %v, wantErr %v", err, tt.wantErr)
 				return
@@ -296,7 +296,7 @@ func TestBuildOpenAPISchema(t *testing.T) {
 }
 
 func TestLoadPreDefinedTypes(t *testing.T) {
-	transformer := NewTransformer()
+	transformer := newTransformer()
 
 	preDefinedTypes := map[string]interface{}{
 		"Person": map[string]interface{}{
@@ -313,7 +313,7 @@ func TestLoadPreDefinedTypes(t *testing.T) {
 		},
 	}
 
-	err := transformer.LoadPreDefinedTypes(preDefinedTypes)
+	err := transformer.loadPreDefinedTypes(preDefinedTypes)
 	if err != nil {
 		t.Fatalf("LoadPreDefinedTypes() error = %v", err)
 	}