chore: remove unused code from apischema package (#87)

Author: aaronschweig

listener/pkg/apischema/builder.go

@@ -133,35 +133,6 @@ func (b *SchemaBuilder) WithScope(rm meta.RESTMapper) *SchemaBuilder {
 	return b
 }
 
-func (b *SchemaBuilder) WithCRDCategories(crd *apiextensionsv1.CustomResourceDefinition) *SchemaBuilder {
-	if crd == nil {
-		return b
-	}
-
-	categories := crd.Spec.Names.Categories
-	if len(categories) == 0 {
-		return b
-	}
-
-	gvk, err := getCRDGroupVersionKind(crd.Spec)
-	if err != nil {
-		b.err = multierror.Append(b.err, errors.Join(ErrGetCRDGVK, err))
-		return b
-	}
-
-	for _, v := range crd.Spec.Versions {
-		resourceKey := getOpenAPISchemaKey(metav1.GroupVersionKind{Group: gvk.Group, Version: v.Name, Kind: gvk.Kind})
-		resourceSchema, ok := b.schemas[resourceKey]
-		if !ok {
-			continue
-		}
-
-		resourceSchema.VendorExtensible.AddExtension(common.CategoriesExtensionKey, categories)
-		b.schemas[resourceKey] = resourceSchema
-	}
-	return b
-}
-
 func (b *SchemaBuilder) WithApiResourceCategories(list []*metav1.APIResourceList) *SchemaBuilder {
 	if len(list) == 0 {
 		return b
@@ -561,16 +532,3 @@ func getOpenAPISchemaKey(gvk metav1.GroupVersionKind) string {
 
 	return fmt.Sprintf("%s.%s.%s", reversedGroup, gvk.Version, gvk.Kind)
 }
-
-func getCRDGroupVersionKind(spec apiextensionsv1.CustomResourceDefinitionSpec) (*metav1.GroupVersionKind, error) {
-	if len(spec.Versions) == 0 {
-		return nil, ErrCRDNoVersions
-	}
-
-	// Use the first stored version as the preferred one
-	return &metav1.GroupVersionKind{
-		Group:   spec.Group,
-		Version: spec.Versions[0].Name,
-		Kind:    spec.Names.Kind,
-	}, nil
-}

listener/pkg/apischema/builder_test.go

@@ -40,52 +40,6 @@ func TestGetOpenAPISchemaKey(t *testing.T) {
 	}
 }
 
-// TestGetCRDGroupVersionKind tests the getCRDGroupVersionKind function. It checks if the
-// function correctly extracts the GroupVersionKind from the CRD spec and handles errors.
-func TestGetCRDGroupVersionKind(t *testing.T) {
-	tests := []struct {
-		name    string
-		spec    apiextensionsv1.CustomResourceDefinitionSpec
-		want    *metav1.GroupVersionKind
-		wantErr error
-	}{
-		{
-			name: "has_versions",
-			spec: apiextensionsv1.CustomResourceDefinitionSpec{
-				Group: "test.group",
-				Versions: []apiextensionsv1.CustomResourceDefinitionVersion{
-					{Name: "v1beta1"},
-					{Name: "v1"},
-				},
-				Names: apiextensionsv1.CustomResourceDefinitionNames{Kind: "Foo"},
-			},
-			want:    &metav1.GroupVersionKind{Group: "test.group", Version: "v1beta1", Kind: "Foo"},
-			wantErr: nil,
-		},
-		{
-			name: "no_versions",
-			spec: apiextensionsv1.CustomResourceDefinitionSpec{
-				Group:    "empty.group",
-				Versions: []apiextensionsv1.CustomResourceDefinitionVersion{},
-				Names:    apiextensionsv1.CustomResourceDefinitionNames{Kind: "Bar"},
-			},
-			want:    nil,
-			wantErr: apischema.ErrCRDNoVersions,
-		},
-	}
-
-	for _, tc := range tests {
-		t.Run(tc.name, func(t *testing.T) {
-			got, err := apischema.GetCRDGroupVersionKind(tc.spec)
-			assert.Equal(t, tc.wantErr, err, "error value mismatch")
-			if tc.wantErr != nil {
-				return
-			}
-			assert.Equal(t, tc.want, got, "result value mismatch")
-		})
-	}
-}
-
 // TestNewSchemaBuilder tests the NewSchemaBuilder function. It checks if the
 // SchemaBuilder is correctly initialized with the expected number of schemas
 // and the expected schema key.
@@ -150,69 +104,6 @@ func TestNewSchemaBuilder(t *testing.T) {
 	}
 }
 
-// TestWithCRDCategories tests the WithCRDCategories method
-// for the SchemaBuilder struct. It checks if the categories are correctly added
-// to the schema's extensions.
-func TestWithCRDCategories(t *testing.T) {
-	tests := []struct {
-		name     string
-		key      string
-		crd      *apiextensionsv1.CustomResourceDefinition
-		wantCats []string
-	}{
-		{
-			name: "adds_categories",
-			key:  "g.v1.K",
-			crd: &apiextensionsv1.CustomResourceDefinition{
-				Spec: apiextensionsv1.CustomResourceDefinitionSpec{
-					Group:    "g",
-					Versions: []apiextensionsv1.CustomResourceDefinitionVersion{{Name: "v1"}},
-					Names: apiextensionsv1.CustomResourceDefinitionNames{
-						Kind:       "K",
-						Categories: []string{"cat1", "cat2"},
-					},
-				},
-			},
-			wantCats: []string{"cat1", "cat2"},
-		},
-		{
-			name: "no_categories",
-			key:  "g.v1.K",
-			crd: &apiextensionsv1.CustomResourceDefinition{
-				Spec: apiextensionsv1.CustomResourceDefinitionSpec{
-					Group:    "g",
-					Versions: []apiextensionsv1.CustomResourceDefinitionVersion{{Name: "v1"}},
-					Names: apiextensionsv1.CustomResourceDefinitionNames{
-						Kind: "K",
-					},
-				},
-			},
-			wantCats: nil,
-		},
-	}
-	for _, tc := range tests {
-		t.Run(tc.name, func(t *testing.T) {
-			mock := apischemaMocks.NewMockClient(t)
-			mock.EXPECT().Paths().Return(map[string]openapi.GroupVersion{}, nil)
-			b := apischema.NewSchemaBuilder(mock, nil, testlogger.New().Logger)
-			b.SetSchemas(map[string]*spec.Schema{
-				tc.key: {VendorExtensible: spec.VendorExtensible{Extensions: map[string]interface{}{}}},
-			})
-			b.WithCRDCategories(tc.crd)
-			ext, found := b.GetSchemas()[tc.key].VendorExtensible.Extensions[common.CategoriesExtensionKey]
-			if tc.wantCats == nil {
-				assert.False(t, found, "expected no categories")
-				return
-			}
-			assert.True(t, found, "expected CategoriesExtensionKey to be set")
-			cats, ok := ext.([]string)
-			assert.True(t, ok, "categories should be []string")
-			assert.Equal(t, len(tc.wantCats), len(cats))
-			assert.Equal(t, tc.wantCats, cats, "categories mismatch")
-		})
-	}
-}
-
 // TestWithApiResourceCategories tests the WithApiResourceCategories method
 // for the SchemaBuilder struct. It checks if the categories are correctly added
 // to the schema's extensions.

listener/pkg/apischema/crd_resolver.go

@@ -7,31 +7,21 @@ import (
 	"strings"
 
 	"github.com/platform-mesh/golang-commons/logger"
-	apiextensionsv1 "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1"
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 
 	"k8s.io/apimachinery/pkg/api/meta"
-	"k8s.io/apimachinery/pkg/runtime/schema"
 	"k8s.io/client-go/discovery"
 	"k8s.io/client-go/openapi"
 	"k8s.io/kube-openapi/pkg/validation/spec"
 )
 
 var (
-	ErrInvalidPath              = errors.New("path doesn't contain the / separator")
-	ErrNotPreferred             = errors.New("path ApiGroup does not belong to the server preferred APIs")
-	ErrGVKNotPreferred          = errors.New("failed to find CRD GVK in API preferred resources")
-	ErrGetServerPreferred       = errors.New("failed to get server preferred resources")
-	ErrFilterPreferredResources = errors.New("failed to filter server preferred resources")
-	ErrGetSchemaForPath         = errors.New("failed to get schema for path")
-	ErrUnmarshalSchemaForPath   = errors.New("failed to unmarshal schema for path")
+	ErrInvalidPath            = errors.New("path doesn't contain the / separator")
+	ErrNotPreferred           = errors.New("path ApiGroup does not belong to the server preferred APIs")
+	ErrGetServerPreferred     = errors.New("failed to get server preferred resources")
+	ErrGetSchemaForPath       = errors.New("failed to get schema for path")
+	ErrUnmarshalSchemaForPath = errors.New("failed to unmarshal schema for path")
 )
 
-type GroupKindVersions struct {
-	*metav1.GroupKind
-	Versions []string
-}
-
 type CRDResolver struct {
 	discovery.DiscoveryInterface
 	meta.RESTMapper
@@ -51,126 +41,6 @@ func (cr *CRDResolver) Resolve(dc discovery.DiscoveryInterface, rm meta.RESTMapp
 	return cr.resolveSchema(dc, rm)
 }
 
-func (cr *CRDResolver) ResolveApiSchema(crd *apiextensionsv1.CustomResourceDefinition) ([]byte, error) {
-	gkv := getCRDGroupKindVersions(crd.Spec)
-
-	apiResLists, err := cr.ServerPreferredResources()
-	if err != nil {
-		cr.log.Error().Err(err).
-			Str("crdName", crd.Name).
-			Str("group", gkv.Group).
-			Str("kind", gkv.Kind).
-			Msg("failed to get server preferred resources")
-		return nil, errors.Join(ErrGetServerPreferred, err)
-	}
-
-	preferredApiGroups, err := cr.errorIfCRDNotInPreferredApiGroups(gkv, apiResLists)
-	if err != nil {
-		cr.log.Error().Err(err).
-			Str("crdName", crd.Name).
-			Str("group", gkv.Group).
-			Str("kind", gkv.Kind).
-			Msg("failed to filter preferred resources")
-		return nil, errors.Join(ErrFilterPreferredResources, err)
-	}
-
-	result, err := NewSchemaBuilder(cr.OpenAPIV3(), preferredApiGroups, cr.log).
-		WithScope(cr.RESTMapper).
-		WithPreferredVersions(apiResLists).
-		WithCRDCategories(crd).
-		WithRelationships().
-		Complete()
-
-	if err != nil {
-		cr.log.Error().Err(err).
-			Str("crdName", crd.Name).
-			Int("preferredApiGroupsCount", len(preferredApiGroups)).
-			Msg("failed to complete schema building")
-		return nil, err
-	}
-
-	cr.log.Debug().
-		Str("crdName", crd.Name).
-		Str("group", gkv.Group).
-		Str("kind", gkv.Kind).
-		Msg("successfully resolved API schema")
-
-	return result, nil
-}
-
-func (cr *CRDResolver) errorIfCRDNotInPreferredApiGroups(gkv *GroupKindVersions, apiResLists []*metav1.APIResourceList) ([]string, error) {
-	isKindFound := false
-	preferredApiGroups := make([]string, 0, len(apiResLists))
-
-	for _, apiResources := range apiResLists {
-		gv, err := schema.ParseGroupVersion(apiResources.GroupVersion)
-		if err != nil {
-			cr.log.Error().Err(err).
-				Str("groupVersion", apiResources.GroupVersion).
-				Str("targetGroup", gkv.Group).
-				Str("targetKind", gkv.Kind).
-				Msg("failed to parse group version")
-			continue
-		}
-
-		isGroupFound := gkv.Group == gv.Group
-		isVersionFound := slices.Contains(gkv.Versions, gv.Version)
-
-		if isGroupFound && isVersionFound && !isKindFound {
-			isKindFound = isCRDKindIncluded(gkv, apiResources)
-			cr.log.Debug().
-				Str("groupVersion", apiResources.GroupVersion).
-				Str("targetGroup", gkv.Group).
-				Str("targetKind", gkv.Kind).
-				Bool("kindFound", isKindFound).
-				Msg("checking if CRD kind is included in preferred APIs")
-		}
-
-		preferredApiGroups = append(preferredApiGroups, apiResources.GroupVersion)
-	}
-
-	if !isKindFound {
-		cr.log.Warn().
-			Str("group", gkv.Group).
-			Str("kind", gkv.Kind).
-			Strs("versions", gkv.Versions).
-			Int("checkedApiGroups", len(preferredApiGroups)).
-			Msg("CRD kind not found in preferred API resources")
-		return nil, ErrGVKNotPreferred
-	}
-
-	cr.log.Debug().
-		Str("group", gkv.Group).
-		Str("kind", gkv.Kind).
-		Int("preferredApiGroupsCount", len(preferredApiGroups)).
-		Msg("successfully found CRD in preferred API groups")
-
-	return preferredApiGroups, nil
-}
-
-func isCRDKindIncluded(gvk *GroupKindVersions, apiResources *metav1.APIResourceList) bool {
-	for _, res := range apiResources.APIResources {
-		if res.Kind == gvk.Kind {
-			return true
-		}
-	}
-	return false
-}
-
-func getCRDGroupKindVersions(spec apiextensionsv1.CustomResourceDefinitionSpec) *GroupKindVersions {
-	versions := make([]string, 0, len(spec.Versions))
-	for _, v := range spec.Versions {
-		versions = append(versions, v.Name)
-	}
-	return &GroupKindVersions{
-		GroupKind: &metav1.GroupKind{
-			Group: spec.Group,
-			Kind:  spec.Names.Kind,
-		},
-		Versions: versions,
-	}
-}
-
 func getSchemaForPath(preferredApiGroups []string, path string, gv openapi.GroupVersion) (map[string]*spec.Schema, error) {
 	if !strings.Contains(path, separator) {
 		return nil, ErrInvalidPath