Add NewPerVersionTraslators function (#2951)

* Add NewPerVersionTraslators function

* Clarify To&FromAPI interfaces and fix FromAPI returns

* Remove the Request

Author: josvazg

internal/crapi/crapi.go

@@ -20,7 +20,6 @@ import (
 	"reflect"
 
 	"github.com/getkin/kin-openapi/openapi3"
-	"github.com/go-logr/logr"
 	"sigs.k8s.io/controller-runtime/pkg/client"
 
 	"github.com/mongodb/mongodb-atlas-kubernetes/v2/internal/crapi/refs"
@@ -39,39 +38,44 @@ type Translator interface {
 	Mappings() ([]*refs.Mapping, error)
 }
 
-// Request holds common parameters for all translation request
+// Request is deprecated do not use
+//
+// Deprecated: request is no longer used in the ToAPI and FromAPI calls
 type Request struct {
 	Translator   Translator
-	Log          logr.Logger
 	Dependencies []client.Object
 }
 
 // APIImporter can translate itself into Kubernetes Objects.
 // Use to customize or accelerate translations ad-hoc
 type APIImporter[T any, P refs.PtrClientObj[T]] interface {
-	FromAPI(tr *Request, target P) ([]client.Object, error)
+	FromAPI(tr Translator, target P, objs ...client.Object) ([]client.Object, error)
 }
 
 // APIExporter can translate itself to an API Object.
 // Use to customize or accelerate translations ad-hoc
 type APIExporter[T any] interface {
-	ToAPI(tr *Request, target *T) error
+	ToAPI(tr Translator, target *T, objs ...client.Object) error
 }
 
 // ToAPI translates a source Kubernetes spec into a target API structure.
 // It uses the spec only to populate ethe API request, nothing from the status.
-func ToAPI[T any](r *Request, target *T, source client.Object) error {
+// The target is set to a API request struct to be filled.
+// The source is set to the Kubernetes CR value. Only the spec data is used here.
+// The request includes the translator and the dependencies associated with the
+// source CR, usually Kubernetes secrets.
+func ToAPI[T any](tr Translator, target *T, source client.Object, objs ...client.Object) error {
 	exporter, ok := (source).(APIExporter[T])
 	if ok {
-		return exporter.ToAPI(r, target)
+		return exporter.ToAPI(tr, target)
 	}
 	unstructuredSrc, err := unstructured.ToUnstructured(source)
 	if err != nil {
 		return fmt.Errorf("failed to convert k8s source value to unstructured: %w", err)
 	}
 	targetUnstructured := map[string]any{}
 
-	if err := collapseReferences(r, unstructuredSrc, source); err != nil {
+	if err := collapseReferences(tr, unstructuredSrc, source, objs); err != nil {
 		return fmt.Errorf("failed to process API mappings: %w", err)
 	}
 
@@ -80,7 +84,7 @@ func ToAPI[T any](r *Request, target *T, source client.Object) error {
 		return fmt.Errorf("target must be a struct but got %v", targetType.Kind())
 	}
 
-	value, err := unstructured.GetField[map[string]any](unstructuredSrc, "spec", r.Translator.MajorVersion())
+	value, err := unstructured.GetField[map[string]any](unstructuredSrc, "spec", tr.MajorVersion())
 	if err != nil {
 		return fmt.Errorf("failed to access source spec value: %w", err)
 	}
@@ -98,10 +102,18 @@ func ToAPI[T any](r *Request, target *T, source client.Object) error {
 // FromAPI translates a source API structure into a Kubernetes object.
 // The API source is used to populate the Kubernetes spec, including the
 // spec.entry and status as well.
-func FromAPI[S any, T any, P refs.PtrClientObj[T]](r *Request, target P, source *S) ([]client.Object, error) {
+// The target is set to CR value to be filled. Both spec and stuatus are filled.
+// The source is set to API response.
+// The request includes the translator and any dependencies associated with the
+// source CR.
+// Returns any extra objects extracted from the response as separate Kubernetes
+// objects, such as Kubernetes secrets, for instance. This list does not include
+// the mutated target, and will be empty if nothing else was extracted off the ç
+// response.
+func FromAPI[S any, T any, P refs.PtrClientObj[T]](tr Translator, target P, source *S, objs ...client.Object) ([]client.Object, error) {
 	importer, ok := any(source).(APIImporter[T, P])
 	if ok {
-		return importer.FromAPI(r, target)
+		return importer.FromAPI(tr, target, objs...)
 	}
 	sourceUnstructured, err := unstructured.ToUnstructured(source)
 	if err != nil {
@@ -114,12 +126,12 @@ func FromAPI[S any, T any, P refs.PtrClientObj[T]](r *Request, target P, source
 	}
 
 	versionedSpec, err := unstructured.GetOrCreateField(
-		targetUnstructured, map[string]any{}, "spec", r.Translator.MajorVersion())
+		targetUnstructured, map[string]any{}, "spec", tr.MajorVersion())
 	if err != nil {
 		return nil, fmt.Errorf("failed to ensure versioned spec object in unstructured target: %w", err)
 	}
 	versionedStatus, err := unstructured.GetOrCreateField(
-		targetUnstructured, map[string]any{}, "status", r.Translator.MajorVersion())
+		targetUnstructured, map[string]any{}, "status", tr.MajorVersion())
 	if err != nil {
 		return nil, fmt.Errorf("failed to create versioned status object in unstructured target: %w", err)
 	}
@@ -130,36 +142,36 @@ func FromAPI[S any, T any, P refs.PtrClientObj[T]](r *Request, target P, source
 	versionedSpec["entry"] = versionedSpecEntry
 	unstructured.CopyFields(versionedStatus, sourceUnstructured)
 
-	extraObjects, err := expandReferences(r, targetUnstructured, target)
+	extraObjects, err := expandReferences(tr, targetUnstructured, target, objs)
 	if err != nil {
 		return nil, fmt.Errorf("failed to process API mappings: %w", err)
 	}
 	if err := unstructured.FromUnstructured(target, targetUnstructured); err != nil {
 		return nil, fmt.Errorf("failed set structured kubernetes object from unstructured: %w", err)
 	}
-	return append([]client.Object{target}, extraObjects...), nil
+	return extraObjects, nil
 }
 
 // collapseReferences finds all Kubernetes references, solves them and collapses
 // them by replacing their values from the reference (e.g Kubernetes secret or
 // group), into the corresponding API request value
-func collapseReferences(r *Request, req map[string]any, main client.Object) error {
-	mappings, err := r.Translator.Mappings()
+func collapseReferences(tr Translator, req map[string]any, main client.Object, objs []client.Object) error {
+	mappings, err := tr.Mappings()
 	if err != nil {
 		return fmt.Errorf("failed to extract mappings to collapse: %w", err)
 	}
-	return refs.CollapseAll(mappings, main, r.Dependencies, req)
+	return refs.CollapseAll(mappings, main, objs, req)
 }
 
 // expandReferences finds all API fields that must be referenced, and expand
 // such reference, moving the value (e.g. sensitive field or group id) to a
 // referenced Kubernetes object (e.g. Kubernetes secret or Atlas Group)
-func expandReferences(r *Request, cr map[string]any, main client.Object) ([]client.Object, error) {
-	mappings, err := r.Translator.Mappings()
+func expandReferences(tr Translator, cr map[string]any, main client.Object, objs []client.Object) ([]client.Object, error) {
+	mappings, err := tr.Mappings()
 	if err != nil {
 		return nil, fmt.Errorf("failed to extract mappings to expand: %w", err)
 	}
-	return refs.ExpandAll(mappings, main, r.Dependencies, cr)
+	return refs.ExpandAll(mappings, main, objs, cr)
 }
 
 func propertyValueOrNil(schema *openapi3.Schema, propertyName string) *openapi3.Schema {