feat: virtual workspace which watches ApiBindings and Workspaces (#141)

* feat: virtual workspace which watches ApiBindings and Workspaces

On-behalf-of: @SAP [email protected]
Signed-off-by: Artem Shcherbatiuk <[email protected]>

* chore: errors.Join

On-behalf-of: @SAP [email protected]
Signed-off-by: Artem Shcherbatiuk <[email protected]>

* feat: removed reconcilingFactory due to compexity overhead

On-behalf-of: @SAP [email protected]
Signed-off-by: Artem Shcherbatiuk <[email protected]>

---------

Signed-off-by: Artem Shcherbatiuk <[email protected]>

Author: vertex451

.mockery.yaml

@@ -2,6 +2,12 @@ issue-845-fix: true
 resolve-type-alias: false
 with-expecter: true
 packages:
+  k8s.io/client-go/discovery:
+    config:
+      dir: listener/kcp/mocks
+      outpkg: mocks
+    interfaces:
+      DiscoveryInterface:
   sigs.k8s.io/controller-runtime/pkg/client:
     config:
       dir: gateway/resolver/mocks

cmd/listener.go

@@ -2,6 +2,8 @@ package cmd
 
 import (
 	"crypto/tls"
+	"github.com/openmfp/kubernetes-graphql-gateway/listener/discoveryclient"
+	"k8s.io/client-go/discovery"
 	"os"
 
 	kcpapis "github.com/kcp-dev/kcp/sdk/apis/apis/v1alpha1"
@@ -36,7 +38,7 @@ var (
 	setupLog             = ctrl.Log.WithName("setup")
 	webhookServer        webhook.Server
 	metricsServerOptions metricsserver.Options
-	appCfg               *config.Config
+	appCfg               config.Config
 )
 
 var listenCmd = &cobra.Command{
@@ -87,7 +89,8 @@ var listenCmd = &cobra.Command{
 		}
 	},
 	Run: func(cmd *cobra.Command, args []string) {
-		cfg := ctrl.GetConfigOrDie()
+		ctx := ctrl.SetupSignalHandler()
+		restCfg := ctrl.GetConfigOrDie()
 
 		mgrOpts := ctrl.Options{
 			Scheme:                 scheme,
@@ -98,32 +101,44 @@ var listenCmd = &cobra.Command{
 			LeaderElectionID:       "72231e1f.openmfp.io",
 		}
 
-		clt, err := client.New(cfg, client.Options{
+		clt, err := client.New(restCfg, client.Options{
 			Scheme: scheme,
 		})
 		if err != nil {
 			setupLog.Error(err, "failed to create client from config")
 			os.Exit(1)
 		}
 
-		mf := &kcp.ManagerFactory{
-			IsKCPEnabled: appCfg.EnableKcp,
-		}
+		mf := kcp.NewManagerFactory(appCfg)
 
-		mgr, err := mf.NewManager(cfg, mgrOpts, clt)
+		mgr, err := mf.NewManager(ctx, restCfg, mgrOpts, clt)
 		if err != nil {
 			setupLog.Error(err, "unable to start manager")
 			os.Exit(1)
 		}
 
+		discoveryInterface, err := discovery.NewDiscoveryClientForConfig(restCfg)
+		if err != nil {
+			setupLog.Error(err, "failed to create discovery client")
+			os.Exit(1)
+		}
+
 		reconcilerOpts := kcp.ReconcilerOpts{
 			Scheme:                 scheme,
 			Client:                 clt,
-			Config:                 cfg,
+			Config:                 restCfg,
 			OpenAPIDefinitionsPath: appCfg.OpenApiDefinitionsPath,
 		}
 
-		reconciler, err := kcp.NewReconcilerFactory(appCfg).NewReconciler(reconcilerOpts)
+		reconciler, err := kcp.NewReconciler(
+			ctx,
+			appCfg,
+			reconcilerOpts,
+			discoveryInterface,
+			kcp.PreReconcile,
+			discoveryclient.NewFactory,
+		)
+
 		if err != nil {
 			setupLog.Error(err, "unable to instantiate reconciler")
 			os.Exit(1)
@@ -144,8 +159,7 @@ var listenCmd = &cobra.Command{
 		}
 
 		setupLog.Info("starting manager")
-		signalHandler := ctrl.SetupSignalHandler()
-		if err := mgr.Start(signalHandler); err != nil {
+		if err := mgr.Start(ctx); err != nil {
 			setupLog.Error(err, "problem running manager")
 			os.Exit(1)
 		}

common/config/config.go

@@ -38,11 +38,13 @@ type Listener struct {
 	ProbeAddr            string `envconfig:"default=:8081,optional"`
 	SecureMetrics        bool   `envconfig:"default=true,optional"`
 	EnableHTTP2          bool   `envconfig:"default=false,optional"`
+	ApiExportWorkspace   string `envconfig:"default=:root,optional"`
+	ApiExportName        string `envconfig:"default=kubernetes.graphql.gateway,optional"`
 }
 
 // NewFromEnv creates a Gateway from environment values
-func NewFromEnv() (*Config, error) {
-	cfg := &Config{}
-	err := envconfig.Init(cfg)
+func NewFromEnv() (Config, error) {
+	cfg := Config{}
+	err := envconfig.Init(&cfg)
 	return cfg, err
 }

gateway/manager/manager.go

@@ -39,7 +39,7 @@ type FileWatcher interface {
 }
 
 type Service struct {
-	appCfg   *appConfig.Config
+	appCfg   appConfig.Config
 	handlers map[string]*graphqlHandler
 	log      *logger.Logger
 	mu       sync.RWMutex
@@ -53,7 +53,7 @@ type graphqlHandler struct {
 	handler http.Handler
 }
 
-func NewManager(log *logger.Logger, cfg *rest.Config, appCfg *appConfig.Config) (*Service, error) {
+func NewManager(log *logger.Logger, cfg *rest.Config, appCfg appConfig.Config) (*Service, error) {
 	watcher, err := fsnotify.NewWatcher()
 	if err != nil {
 		return nil, err

go.mod

@@ -16,6 +16,7 @@ require (
 	github.com/graphql-go/graphql v0.8.1
 	github.com/graphql-go/handler v0.2.4
 	github.com/hashicorp/go-multierror v1.1.1
+	github.com/kcp-dev/kcp/pkg/apis v0.11.0
 	github.com/kcp-dev/kcp/sdk v0.27.0
 	github.com/kcp-dev/logicalcluster/v3 v3.0.5
 	github.com/mitchellh/mapstructure v1.5.0

go.sum

@@ -94,6 +94,8 @@ github.com/kcp-dev/apimachinery/v2 v2.0.1-0.20250223115924-431177b024f3 h1:YwNX7
 github.com/kcp-dev/apimachinery/v2 v2.0.1-0.20250223115924-431177b024f3/go.mod h1:n0+EV+LGKl1MXXqGbGcn0AaBv7hdKsdazSYuq8nM8Us=
 github.com/kcp-dev/controller-runtime v0.19.0-kcp.1.0.20250129100209-5eaf4c7b6056 h1:NaEaA34bHNawPL3npJN8J7jyQhA3eG+UQ0xZvTnOfYo=
 github.com/kcp-dev/controller-runtime v0.19.0-kcp.1.0.20250129100209-5eaf4c7b6056/go.mod h1:jwK5sBnpu/xJJ+xdpSzzI0aM52E/EvF0uLF9bR61h/Y=
+github.com/kcp-dev/kcp/pkg/apis v0.11.0 h1:K6p+tNHNcvfACCPLcHgY0EMLeaIwR1jS491FyLfXMII=
+github.com/kcp-dev/kcp/pkg/apis v0.11.0/go.mod h1:8cUAmfMJcksauz53UtsLYG8Phhx62rvuCnd/5t/Zihk=
 github.com/kcp-dev/kcp/sdk v0.27.0 h1:j32awoUYAJJGPKXDEWXZCrYsKWMBuL/7YnDDSLRxJvA=
 github.com/kcp-dev/kcp/sdk v0.27.0/go.mod h1:3eRgW42d81Ng60DbG1xbne0FSS2znpcN/GUx4rqJgUo=
 github.com/kcp-dev/logicalcluster/v3 v3.0.5 h1:JbYakokb+5Uinz09oTXomSUJVQsqfxEvU4RyHUYxHOU=

listener/apischema/builder.go

@@ -2,6 +2,7 @@ package apischema
 
 import (
 	"encoding/json"
+	"errors"
 	"fmt"
 	"k8s.io/apimachinery/pkg/api/meta"
 	"maps"
@@ -19,6 +20,17 @@ import (
 	"k8s.io/kube-openapi/pkg/validation/spec"
 )
 
+var (
+	ErrGetOpenAPIPaths      = errors.New("failed to get OpenAPI paths")
+	ErrGetCRDGVK            = errors.New("failed to get CRD GVK")
+	ErrParseGroupVersion    = errors.New("failed to parse groupVersion")
+	ErrMarshalOpenAPISchema = errors.New("failed to marshal openAPI v3 runtimeSchema")
+	ErrConvertOpenAPISchema = errors.New("failed to convert openAPI v3 runtimeSchema to v2")
+	ErrCRDNoVersions        = errors.New("CRD has no versions defined")
+	ErrMarshalGVK           = errors.New("failed to marshal GVK extension")
+	ErrUnmarshalGVK         = errors.New("failed to unmarshal GVK extension")
+)
+
 // SchemaBuilder helps construct GraphQL field config arguments
 type SchemaBuilder struct {
 	schemas map[string]*spec.Schema
@@ -32,7 +44,7 @@ func NewSchemaBuilder(oc openapi.Client, preferredApiGroups []string) *SchemaBui
 
 	apiv3Paths, err := oc.Paths()
 	if err != nil {
-		b.err = multierror.Append(b.err, fmt.Errorf("failed to get OpenAPI paths: %w", err))
+		b.err = multierror.Append(b.err, errors.Join(ErrGetOpenAPIPaths, err))
 		return b
 	}
 
@@ -66,14 +78,14 @@ func (b *SchemaBuilder) WithScope(rm meta.RESTMapper) *SchemaBuilder {
 		if gvksVal, ok = schema.VendorExtensible.Extensions[common.GVKExtensionKey]; !ok {
 			continue
 		}
-		b, err := json.Marshal(gvksVal)
+		jsonBytes, err := json.Marshal(gvksVal)
 		if err != nil {
-			//TODO: debug log?
+			b.err = multierror.Append(b.err, errors.Join(ErrMarshalGVK, err))
 			continue
 		}
 		gvks := make([]*GroupVersionKind, 0, 1)
-		if err := json.Unmarshal(b, &gvks); err != nil {
-			//TODO: debug log?
+		if err := json.Unmarshal(jsonBytes, &gvks); err != nil {
+			b.err = multierror.Append(b.err, errors.Join(ErrUnmarshalGVK, err))
 			continue
 		}
 
@@ -111,7 +123,7 @@ func (b *SchemaBuilder) WithCRDCategories(crd *apiextensionsv1.CustomResourceDef
 	}
 	gvk, err := getCRDGroupVersionKind(crd.Spec)
 	if err != nil {
-		b.err = multierror.Append(b.err, fmt.Errorf("failed to get CRD GVK: %w", err))
+		b.err = multierror.Append(b.err, errors.Join(ErrGetCRDGVK, err))
 		return b
 	}
 
@@ -134,7 +146,7 @@ func (b *SchemaBuilder) WithApiResourceCategories(list []*metav1.APIResourceList
 
 			gv, err := runtimeSchema.ParseGroupVersion(apiResourceList.GroupVersion)
 			if err != nil {
-				b.err = multierror.Append(b.err, fmt.Errorf("failed to parse groupVersion: %w", err))
+				b.err = multierror.Append(b.err, errors.Join(ErrParseGroupVersion, err))
 				continue
 			}
 			gvk := metav1.GroupVersionKind{
@@ -162,12 +174,12 @@ func (b *SchemaBuilder) Complete() ([]byte, error) {
 		},
 	})
 	if err != nil {
-		b.err = multierror.Append(b.err, fmt.Errorf("failed to marshal openAPI v3 runtimeSchema: %w", err))
+		b.err = multierror.Append(b.err, errors.Join(ErrMarshalOpenAPISchema, err))
 		return nil, b.err
 	}
 	v2JSON, err := ConvertJSON(v3JSON)
 	if err != nil {
-		b.err = multierror.Append(b.err, fmt.Errorf("failed to convert openAPI v3 runtimeSchema to v2: %w", err))
+		b.err = multierror.Append(b.err, errors.Join(ErrConvertOpenAPISchema, err))
 		return nil, b.err
 	}
 
@@ -185,7 +197,7 @@ func getOpenAPISchemaKey(gvk metav1.GroupVersionKind) string {
 
 func getCRDGroupVersionKind(spec apiextensionsv1.CustomResourceDefinitionSpec) (*metav1.GroupVersionKind, error) {
 	if len(spec.Versions) == 0 {
-		return nil, fmt.Errorf("CRD has no versions defined")
+		return nil, ErrCRDNoVersions
 	}
 
 	// Use the first stored version as the preferred one

listener/apischema/crd_resolver.go

@@ -3,7 +3,6 @@ package apischema
 import (
 	"encoding/json"
 	"errors"
-	"fmt"
 	"slices"
 	"strings"
 
@@ -18,9 +17,13 @@ import (
 )
 
 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")
+	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")
 )
 
 type GroupKindVersions struct {
@@ -42,12 +45,12 @@ func (cr *CRDResolver) ResolveApiSchema(crd *apiextensionsv1.CustomResourceDefin
 
 	apiResLists, err := cr.ServerPreferredResources()
 	if err != nil {
-		return nil, fmt.Errorf("failed to get server preferred resources: %w", err)
+		return nil, errors.Join(ErrGetServerPreferred, err)
 	}
 
 	preferredApiGroups, err := errorIfCRDNotInPreferredApiGroups(gkv, apiResLists)
 	if err != nil {
-		return nil, fmt.Errorf("failed to filter server preferred resources: %w", err)
+		return nil, errors.Join(ErrFilterPreferredResources, err)
 	}
 
 	return NewSchemaBuilder(cr.OpenAPIV3(), preferredApiGroups).
@@ -114,20 +117,20 @@ func getSchemaForPath(preferredApiGroups []string, path string, gv openapi.Group
 
 	b, err := gv.Schema(discovery.AcceptV1)
 	if err != nil {
-		return nil, fmt.Errorf("failed to get schema for path %s :%w", path, err)
+		return nil, errors.Join(ErrGetSchemaForPath, err)
 	}
 
 	resp := &schemaResponse{}
 	if err := json.Unmarshal(b, resp); err != nil {
-		return nil, fmt.Errorf("failed to unmarshal schema for path %s :%w", path, err)
+		return nil, errors.Join(ErrUnmarshalSchemaForPath, err)
 	}
 	return resp.Components.Schemas, nil
 }
 
 func resolveSchema(dc discovery.DiscoveryInterface, rm meta.RESTMapper) ([]byte, error) {
 	apiResList, err := dc.ServerPreferredResources()
 	if err != nil {
-		return nil, fmt.Errorf("failed to get server preferred resources: %w", err)
+		return nil, errors.Join(ErrGetServerPreferred, err)
 	}
 
 	var preferredApiGroups []string

listener/apischema/json_converter.go

@@ -4,10 +4,15 @@ import (
 	"bytes"
 	"encoding/json"
 	"errors"
-	"fmt"
 	"strings"
 )
 
+var (
+	ErrFailedToValidateConvertedJson = errors.New("failed to validate converted JSON")
+	ErrUnmarshalJSON                 = errors.New("failed to unmarshal JSON")
+	ErrEncodeJSON                    = errors.New("failed to encode JSON")
+)
+
 type v3Wrapper struct {
 	Schemas map[string]any `json:"schemas"`
 }
@@ -23,25 +28,27 @@ type v2RootWrapper struct {
 func ConvertJSON(v3JSON []byte) ([]byte, error) {
 	data := &v3RootWrapper{}
 	if err := json.Unmarshal(v3JSON, data); err != nil {
-		return nil, fmt.Errorf("failed to unmarshal JSON: %w", err)
+		return nil, errors.Join(ErrUnmarshalJSON, err)
 	}
 
 	v2JSON := parseJSON(data.Components.Schemas)
 	v2, ok := v2JSON.(map[string]any)
 	if !ok {
-		return nil, errors.New("failed to validate converted JSON")
+		return nil, ErrFailedToValidateConvertedJson
 	}
 	buf := &bytes.Buffer{}
 	e := json.NewEncoder(buf)
 	e.SetEscapeHTML(false)
 	encErr := e.Encode(&v2RootWrapper{
 		Definitions: v2,
 	})
-	return buf.Bytes(), encErr
+	if encErr != nil {
+		return nil, errors.Join(ErrEncodeJSON, encErr)
+	}
+	return buf.Bytes(), nil
 }
 
 func parseJSON(data any) any {
-
 	v, ok := data.(map[string]any)
 	if !ok {
 		return data