review and tests

backend/conversion.go

@@ -21,6 +21,11 @@ type ConversionHandler interface {
 
 type ConvertObjectsFunc func(context.Context, *ConversionRequest) (*ConversionResponse, error)
 
+// QueryData calls fn(ctx, req).
+func (fn ConvertObjectsFunc) ConvertObjects(ctx context.Context, req *ConversionRequest) (*ConversionResponse, error) {
+	return fn(ctx, req)
+}
+
 type GroupVersion struct {
 	Group   string `json:"group,omitempty"`
 	Version string `json:"version,omitempty"`

backend/conversion_adapter.go

@@ -37,18 +37,19 @@ func parseAsQueryRequest(req *ConversionRequest) ([]*QueryDataRequest, error) {
 	return requests, nil
 }
 
-func (a *conversionSDKAdapter) ConvertQueryDataRequest(ctx context.Context, requests []*QueryDataRequest) (*ConversionResponse, error) {
+func (a *conversionSDKAdapter) convertQueryDataRequest(ctx context.Context, requests []*QueryDataRequest) (*ConversionResponse, error) {
 	resp := &ConversionResponse{}
-	convertedRequests := make([]QueryDataRequest, 0, len(requests))
+	queries := []any{}
 	for _, req := range requests {
-		res, err := a.queryConversionHandler.ConvertQuery(ctx, req)
+		res, err := a.queryConversionHandler.ConvertQueryDataRequest(ctx, req)
 		if err != nil {
 			return nil, err
 		}
-		convertedRequests = append(convertedRequests, *res.QueryRequest)
+		// Queries are flattened into a single array
+		queries = append(queries, res.Queries...)
 	}
 
-	for _, req := range convertedRequests {
+	for _, req := range queries {
 		newJSON, err := json.Marshal(req)
 		if err != nil {
 			return nil, fmt.Errorf("marshal: %w", err)
@@ -72,7 +73,7 @@ func (a *conversionSDKAdapter) ConvertObjects(ctx context.Context, req *pluginv2
 			// Try to parse it as a query data request
 			reqs, err := parseAsQueryRequest(parsedReq)
 			if err == nil {
-				resp, innerErr = a.ConvertQueryDataRequest(ctx, reqs)
+				resp, innerErr = a.convertQueryDataRequest(ctx, reqs)
 				return RequestStatusFromError(innerErr), innerErr
 			}
 			// The object cannot be parsed as a query data request, so we will try to convert it as a generic object

backend/conversion_adapter_test.go

@@ -0,0 +1,48 @@
+package backend
+
+import (
+	"context"
+	"testing"
+
+	"github.com/grafana/grafana-plugin-sdk-go/genproto/pluginv2"
+	"github.com/stretchr/testify/require"
+)
+
+func TestConvertObjects(t *testing.T) {
+	t.Run("converts a raw object", func(t *testing.T) {
+		input := []byte(`{"foo":"bar"}`)
+		expected := []byte(`{"baz":"qux"}`)
+
+		a := newConversionSDKAdapter(ConvertObjectsFunc(func(_ context.Context, r *ConversionRequest) (*ConversionResponse, error) {
+			require.Equal(t, input, r.Objects[0].Raw)
+			return &ConversionResponse{
+				Objects: []RawObject{{Raw: expected}},
+			}, nil
+		}), nil)
+		res, err := a.ConvertObjects(context.Background(), &pluginv2.ConversionRequest{
+			PluginContext: &pluginv2.PluginContext{},
+			TargetVersion: &pluginv2.GroupVersion{},
+			Objects:       []*pluginv2.RawObject{{Raw: input}},
+		})
+		require.NoError(t, err)
+		require.Equal(t, []*pluginv2.RawObject{{Raw: expected}}, res.Objects)
+	})
+
+	t.Run("converts a query data request", func(t *testing.T) {
+		input := []byte(`{"queries":[{"JSON":"foo"}]}`)
+
+		a := newConversionSDKAdapter(nil, ConvertQueryFunc(func(_ context.Context, r *QueryDataRequest) (*QueryConversionResponse, error) {
+			require.Equal(t, `"foo"`, string(r.Queries[0].JSON))
+			return &QueryConversionResponse{
+				Queries: []any{DataQuery{JSON: []byte(`"bar"`)}},
+			}, nil
+		}))
+		res, err := a.ConvertObjects(context.Background(), &pluginv2.ConversionRequest{
+			PluginContext: &pluginv2.PluginContext{},
+			TargetVersion: &pluginv2.GroupVersion{},
+			Objects:       []*pluginv2.RawObject{{Raw: input, ContentType: "application/json"}},
+		})
+		require.NoError(t, err)
+		require.Contains(t, string(res.Objects[0].Raw), `"JSON":"bar"`)
+	})
+}

backend/query_conversion.go

@@ -6,15 +6,19 @@ import "context"
 
 type QueryConversionHandler interface {
 	// ConvertQuery is called to covert queries between different versions
-	ConvertQuery(ctx context.Context, req *QueryDataRequest) (*QueryConversionResponse, error)
+	ConvertQueryDataRequest(ctx context.Context, req *QueryDataRequest) (*QueryConversionResponse, error)
 }
 
 type ConvertQueryFunc func(ctx context.Context, req *QueryDataRequest) (*QueryConversionResponse, error)
 
+func (fn ConvertQueryFunc) ConvertQueryDataRequest(ctx context.Context, req *QueryDataRequest) (*QueryConversionResponse, error) {
+	return fn(ctx, req)
+}
+
 type QueryConversionResponse struct {
 	// Converted queries. It should extend v0alpha1.Query
-	QueryRequest *QueryDataRequest `json:"query"`
+	Queries []any
 	// Result contains extra details into why an conversion request was denied.
 	// +optional
-	Result *StatusResult `json:"result,omitempty"`
+	Result *StatusResult
 }

internal/automanagement/manager.go

@@ -106,13 +106,13 @@ func (m *Manager) RunStream(ctx context.Context, req *backend.RunStreamRequest,
 	return status.Error(codes.Unimplemented, "unimplemented")
 }
 
-func (m *Manager) ConvertQuery(ctx context.Context, req *backend.QueryDataRequest) (*backend.QueryConversionResponse, error) {
+func (m *Manager) ConvertQueryDataRequest(ctx context.Context, req *backend.QueryDataRequest) (*backend.QueryConversionResponse, error) {
 	h, err := m.Get(ctx, req.PluginContext)
 	if err != nil {
 		return nil, err
 	}
 	if ds, ok := h.(backend.QueryConversionHandler); ok {
-		return ds.ConvertQuery(ctx, req)
+		return ds.ConvertQueryDataRequest(ctx, req)
 	}
 	return nil, status.Error(codes.Unimplemented, "unimplemented")
 }