Query conversion handler

backend/conversion_adapter.go

@@ -2,27 +2,81 @@ package backend
 
 import (
 	"context"
+	"encoding/json"
+	"fmt"
 
 	"github.com/grafana/grafana-plugin-sdk-go/genproto/pluginv2"
 )
 
 type conversionSDKAdapter struct {
-	handler ConversionHandler
+	handler                ConversionHandler
+	queryConversionHandler QueryConversionHandler
 }
 
-func newConversionSDKAdapter(handler ConversionHandler) *conversionSDKAdapter {
+func newConversionSDKAdapter(handler ConversionHandler, queryConversionHandler QueryConversionHandler) *conversionSDKAdapter {
 	return &conversionSDKAdapter{
-		handler: handler,
+		handler:                handler,
+		queryConversionHandler: queryConversionHandler,
 	}
 }
 
+func parseAsQueryRequest(req *ConversionRequest) ([]*QueryDataRequest, error) {
+	var requests []*QueryDataRequest
+	for _, obj := range req.Objects {
+		if obj.ContentType != "application/json" {
+			return nil, fmt.Errorf("unsupported content type %s", obj.ContentType)
+		}
+		input := &QueryDataRequest{}
+		err := json.Unmarshal(obj.Raw, input)
+		if err != nil {
+			return nil, fmt.Errorf("unmarshal: %w", err)
+		}
+		input.PluginContext = req.PluginContext
+		requests = append(requests, input)
+	}
+	return requests, nil
+}
+
+func (a *conversionSDKAdapter) ConvertQueryDataRequest(ctx context.Context, requests []*QueryDataRequest) (*ConversionResponse, error) {
+	resp := &ConversionResponse{}
+	convertedRequests := make([]QueryDataRequest, 0, len(requests))
+	for _, req := range requests {
+		res, err := a.queryConversionHandler.ConvertQuery(ctx, req)
+		if err != nil {
+			return nil, err
+		}
+		convertedRequests = append(convertedRequests, *res.QueryRequest)
+	}
+
+	for _, req := range convertedRequests {
+		newJSON, err := json.Marshal(req)
+		if err != nil {
+			return nil, fmt.Errorf("marshal: %w", err)
+		}
+		resp.Objects = append(resp.Objects, RawObject{
+			Raw:         newJSON,
+			ContentType: "application/json",
+		})
+	}
+	return resp, nil
+}
+
 func (a *conversionSDKAdapter) ConvertObjects(ctx context.Context, req *pluginv2.ConversionRequest) (*pluginv2.ConversionResponse, error) {
 	ctx = setupContext(ctx, EndpointConvertObject)
 	parsedReq := FromProto().ConversionRequest(req)
 
-	var resp *ConversionResponse
+	resp := &ConversionResponse{}
 	err := wrapHandler(ctx, parsedReq.PluginContext, func(ctx context.Context) (RequestStatus, error) {
 		var innerErr error
+		if a.queryConversionHandler != nil {
+			// Try to parse it as a query data request
+			reqs, err := parseAsQueryRequest(parsedReq)
+			if err == nil {
+				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
+		}
 		resp, innerErr = a.handler.ConvertObjects(ctx, parsedReq)
 		return RequestStatusFromError(innerErr), innerErr
 	})

backend/datasource/manage.go

@@ -45,11 +45,13 @@ func Manage(pluginID string, instanceFactory InstanceFactoryFunc, opts ManageOpt
 	}
 	handler := automanagement.NewManager(NewInstanceManager(instanceFactory))
 	return backend.Manage(pluginID, backend.ServeOpts{
-		CheckHealthHandler:  handler,
-		CallResourceHandler: handler,
-		QueryDataHandler:    handler,
-		StreamHandler:       handler,
-		AdmissionHandler:    opts.AdmissionHandler,
-		GRPCSettings:        opts.GRPCSettings,
+		CheckHealthHandler:     handler,
+		CallResourceHandler:    handler,
+		QueryDataHandler:       handler,
+		StreamHandler:          handler,
+		QueryConversionHandler: handler,
+		AdmissionHandler:       opts.AdmissionHandler,
+		GRPCSettings:           opts.GRPCSettings,
+		ConversionHandler:      opts.ConversionHandler,
 	})
 }

backend/query_conversion.go

@@ -0,0 +1,20 @@
+package backend
+
+import "context"
+
+// QueryConversionHandler is an EXPERIMENTAL service that allows converting queries between versions
+
+type QueryConversionHandler interface {
+	// ConvertQuery is called to covert queries between different versions
+	ConvertQuery(ctx context.Context, req *QueryDataRequest) (*QueryConversionResponse, error)
+}
+
+type ConvertQueryFunc func(ctx context.Context, req *QueryDataRequest) (*QueryConversionResponse, error)
+
+type QueryConversionResponse struct {
+	// Converted queries. It should extend v0alpha1.Query
+	QueryRequest *QueryDataRequest `json:"query"`
+	// Result contains extra details into why an conversion request was denied.
+	// +optional
+	Result *StatusResult `json:"result,omitempty"`
+}

backend/serve.go

@@ -65,6 +65,10 @@ type ServeOpts struct {
 	// This is EXPERIMENTAL and is a subject to change till Grafana 12
 	ConversionHandler ConversionHandler
 
+	// QueryConversionHandler converts queries between versions
+	// This is EXPERIMENTAL and is a subject to change till Grafana 12
+	QueryConversionHandler QueryConversionHandler
+
 	// GRPCSettings settings for gPRC.
 	GRPCSettings GRPCSettings
 }
@@ -90,8 +94,8 @@ func GRPCServeOpts(opts ServeOpts) grpcplugin.ServeOpts {
 		pluginOpts.AdmissionServer = newAdmissionSDKAdapter(opts.AdmissionHandler)
 	}
 
-	if opts.ConversionHandler != nil {
-		pluginOpts.ConversionServer = newConversionSDKAdapter(opts.ConversionHandler)
+	if opts.ConversionHandler != nil || opts.QueryConversionHandler != nil {
+		pluginOpts.ConversionServer = newConversionSDKAdapter(opts.ConversionHandler, opts.QueryConversionHandler)
 	}
 	return pluginOpts
 }

internal/automanagement/manager.go

@@ -105,3 +105,14 @@ 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) {
+	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 nil, status.Error(codes.Unimplemented, "unimplemented")
+}