QueryService: Use types from sdk (#84029)

Author: ryantxu

hack/update-codegen.sh

@@ -24,11 +24,11 @@ grafana::codegen:run() {
   local generate_root=$1
   local skipped="true"
   for api_pkg in $(grafana:codegen:lsdirs ./${generate_root}/apis); do
-    echo "Generating code for ${generate_root}/apis/${api_pkg}..."
-    echo "============================================="
     if [[ "${selected_pkg}" != "" && ${api_pkg} != $selected_pkg ]]; then
       continue
     fi
+    echo "Generating code for ${generate_root}/apis/${api_pkg}..."
+    echo "============================================="
     skipped="false"
     include_common_input_dirs=$([[ ${api_pkg} == "common" ]] && echo "true" || echo "false")
 

pkg/apis/query/v0alpha1/types.go pkg/apis/query/v0alpha1/datasource.go

@@ -3,26 +3,10 @@ package v0alpha1
 import (
 	"context"
 
-	"github.com/grafana/grafana-plugin-sdk-go/backend"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/runtime/schema"
 )
 
-// The query runner interface
-type QueryRunner interface {
-	// Runs the query as the user in context
-	ExecuteQueryData(ctx context.Context,
-		// The k8s group for the datasource (pluginId)
-		datasource schema.GroupVersion,
-
-		// The datasource name/uid
-		name string,
-
-		// The raw backend query objects
-		query []GenericDataQuery,
-	) (*backend.QueryDataResponse, error)
-}
-
 type DataSourceApiServerRegistry interface {
 	// Get the group and preferred version for a plugin
 	GetDatasourceGroupVersion(pluginId string) (schema.GroupVersion, error)

pkg/apis/query/v0alpha1/query.go

@@ -1,240 +1,59 @@
 package v0alpha1
 
 import (
-	"encoding/json"
-	"fmt"
+	"net/http"
 
+	"github.com/grafana/grafana-plugin-sdk-go/backend"
+	data "github.com/grafana/grafana-plugin-sdk-go/experimental/apis/data/v0alpha1"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	runtime "k8s.io/apimachinery/pkg/runtime"
 )
 
 // Generic query request with shared time across all values
 // Copied from: https://github.com/grafana/grafana/blob/main/pkg/api/dtos/models.go#L62
-type GenericQueryRequest struct {
+// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object
+type QueryDataRequest struct {
 	metav1.TypeMeta `json:",inline"`
 
-	// From Start time in epoch timestamps in milliseconds or relative using Grafana time units.
-	// example: now-1h
-	From string `json:"from,omitempty"`
-
-	// To End time in epoch timestamps in milliseconds or relative using Grafana time units.
-	// example: now
-	To string `json:"to,omitempty"`
-
-	// queries.refId – Specifies an identifier of the query. Is optional and default to “A”.
-	// queries.datasourceId – Specifies the data source to be queried. Each query in the request must have an unique datasourceId.
-	// queries.maxDataPoints - Species maximum amount of data points that dashboard panel can render. Is optional and default to 100.
-	// queries.intervalMs - Specifies the time interval in milliseconds of time series. Is optional and defaults to 1000.
-	// required: true
-	// example: [ { "refId": "A", "intervalMs": 86400000, "maxDataPoints": 1092, "datasource":{ "uid":"PD8C576611E62080A" }, "rawSql": "SELECT 1 as valueOne, 2 as valueTwo", "format": "table" } ]
-	Queries []GenericDataQuery `json:"queries"`
-
-	// required: false
-	Debug bool `json:"debug,omitempty"`
-}
-
-type DataSourceRef struct {
-	// The datasource plugin type
-	Type string `json:"type"`
-
-	// Datasource UID
-	UID string `json:"uid"`
-}
-
-// GenericDataQuery is a replacement for `dtos.MetricRequest` that provides more explicit types
-type GenericDataQuery struct {
-	// RefID is the unique identifier of the query, set by the frontend call.
-	RefID string `json:"refId"`
-
-	// TimeRange represents the query range
-	// NOTE: unlike generic /ds/query, we can now send explicit time values in each query
-	TimeRange *TimeRange `json:"timeRange,omitempty"`
-
-	// The datasource
-	Datasource *DataSourceRef `json:"datasource,omitempty"`
-
-	// Deprecated -- use datasource ref instead
-	DatasourceId int64 `json:"datasourceId,omitempty"`
-
-	// QueryType is an optional identifier for the type of query.
-	// It can be used to distinguish different types of queries.
-	QueryType string `json:"queryType,omitempty"`
-
-	// MaxDataPoints is the maximum number of data points that should be returned from a time series query.
-	MaxDataPoints int64 `json:"maxDataPoints,omitempty"`
-
-	// Interval is the suggested duration between time points in a time series query.
-	IntervalMS float64 `json:"intervalMs,omitempty"`
-
-	// true if query is disabled (ie should not be returned to the dashboard)
-	// Note this does not always imply that the query should not be executed since
-	// the results from a hidden query may be used as the input to other queries (SSE etc)
-	Hide bool `json:"hide,omitempty"`
-
-	// Additional Properties (that live at the root)
-	props map[string]any `json:"-"`
-}
-
-func NewGenericDataQuery(vals map[string]any) GenericDataQuery {
-	q := GenericDataQuery{}
-	_ = q.unmarshal(vals)
-	return q
-}
-
-// TimeRange represents a time range for a query and is a property of DataQuery.
-type TimeRange struct {
-	// From is the start time of the query.
-	From string `json:"from"`
-
-	// To is the end time of the query.
-	To string `json:"to"`
+	// The time range used when not included on each query
+	data.QueryDataRequest `json:",inline"`
 }
 
-func (g *GenericDataQuery) AdditionalProperties() map[string]any {
-	if g.props == nil {
-		g.props = make(map[string]any)
-	}
-	return g.props
-}
+// Wraps backend.QueryDataResponse, however it includes TypeMeta and implements runtime.Object
+// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object
+type QueryDataResponse struct {
+	metav1.TypeMeta `json:",inline"`
 
-// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
-func (g *GenericDataQuery) DeepCopyInto(out *GenericDataQuery) {
-	*out = *g
-	if g.props != nil {
-		out.props = runtime.DeepCopyJSON(g.props)
-	}
+	// Backend wrapper (external dependency)
+	backend.QueryDataResponse `json:",inline"`
 }
 
-// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new GenericDataQuery.
-func (g *GenericDataQuery) DeepCopy() *GenericDataQuery {
-	if g == nil {
-		return nil
+// If errors exist, return multi-status
+func GetResponseCode(rsp *backend.QueryDataResponse) int {
+	if rsp == nil {
+		return http.StatusInternalServerError
 	}
-	out := new(GenericDataQuery)
-	g.DeepCopyInto(out)
-	return out
-}
-
-// MarshalJSON ensures that the unstructured object produces proper
-// JSON when passed to Go's standard JSON library.
-func (g GenericDataQuery) MarshalJSON() ([]byte, error) {
-	vals := map[string]any{}
-	if g.props != nil {
-		for k, v := range g.props {
-			vals[k] = v
+	for _, v := range rsp.Responses {
+		if v.Error != nil {
+			return http.StatusMultiStatus
 		}
 	}
-
-	vals["refId"] = g.RefID
-	if g.Datasource != nil && (g.Datasource.Type != "" || g.Datasource.UID != "") {
-		vals["datasource"] = g.Datasource
-	}
-	if g.DatasourceId > 0 {
-		vals["datasourceId"] = g.DatasourceId
-	}
-	if g.IntervalMS > 0 {
-		vals["intervalMs"] = g.IntervalMS
-	}
-	if g.MaxDataPoints > 0 {
-		vals["maxDataPoints"] = g.MaxDataPoints
-	}
-	if g.QueryType != "" {
-		vals["queryType"] = g.QueryType
-	}
-	return json.Marshal(vals)
-}
-
-// UnmarshalJSON ensures that the unstructured object properly decodes
-// JSON when passed to Go's standard JSON library.
-func (g *GenericDataQuery) UnmarshalJSON(b []byte) error {
-	vals := map[string]any{}
-	err := json.Unmarshal(b, &vals)
-	if err != nil {
-		return err
-	}
-	return g.unmarshal(vals)
+	return http.StatusOK
 }
 
-func (g *GenericDataQuery) unmarshal(vals map[string]any) error {
-	if vals == nil {
-		g.props = nil
-		return nil
-	}
+// Defines a query behavior in a datasource.  This is a similar model to a CRD where the
+// payload describes a valid query
+// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object
+type QueryTypeDefinition struct {
+	metav1.TypeMeta   `json:",inline"`
+	metav1.ObjectMeta `json:"metadata,omitempty"`
 
-	key := "refId"
-	v, ok := vals[key]
-	if ok {
-		g.RefID, ok = v.(string)
-		if !ok {
-			return fmt.Errorf("expected string refid (got: %t)", v)
-		}
-		delete(vals, key)
-	}
-
-	key = "datasource"
-	v, ok = vals[key]
-	if ok {
-		wrap, ok := v.(map[string]any)
-		if ok {
-			g.Datasource = &DataSourceRef{}
-			g.Datasource.Type, _ = wrap["type"].(string)
-			g.Datasource.UID, _ = wrap["uid"].(string)
-			delete(vals, key)
-		} else {
-			// Old old queries may arrive with just the name
-			name, ok := v.(string)
-			if !ok {
-				return fmt.Errorf("expected datasource as object (got: %t)", v)
-			}
-			g.Datasource = &DataSourceRef{}
-			g.Datasource.UID = name // Not great, but the lookup function will try its best to resolve
-			delete(vals, key)
-		}
-	}
-
-	key = "intervalMs"
-	v, ok = vals[key]
-	if ok {
-		g.IntervalMS, ok = v.(float64)
-		if !ok {
-			return fmt.Errorf("expected intervalMs as float (got: %t)", v)
-		}
-		delete(vals, key)
-	}
-
-	key = "maxDataPoints"
-	v, ok = vals[key]
-	if ok {
-		count, ok := v.(float64)
-		if !ok {
-			return fmt.Errorf("expected maxDataPoints as number (got: %t)", v)
-		}
-		g.MaxDataPoints = int64(count)
-		delete(vals, key)
-	}
-
-	key = "datasourceId"
-	v, ok = vals[key]
-	if ok {
-		count, ok := v.(float64)
-		if !ok {
-			return fmt.Errorf("expected datasourceId as number (got: %t)", v)
-		}
-		g.DatasourceId = int64(count)
-		delete(vals, key)
-	}
+	Spec data.QueryTypeDefinitionSpec `json:"spec,omitempty"`
+}
 
-	key = "queryType"
-	v, ok = vals[key]
-	if ok {
-		queryType, ok := v.(string)
-		if !ok {
-			return fmt.Errorf("expected queryType as string (got: %t)", v)
-		}
-		g.QueryType = queryType
-		delete(vals, key)
-	}
+// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object
+type QueryTypeDefinitionList struct {
+	metav1.TypeMeta `json:",inline"`
+	metav1.ListMeta `json:"metadata,omitempty"`
 
-	g.props = vals
-	return nil
+	Items []QueryTypeDefinition `json:"items,omitempty"`
 }

pkg/apis/query/v0alpha1/query_test.go

@@ -4,9 +4,10 @@ import (
 	"encoding/json"
 	"testing"
 
+	data "github.com/grafana/grafana-plugin-sdk-go/experimental/apis/data/v0alpha1"
 	"github.com/stretchr/testify/require"
 
-	"github.com/grafana/grafana/pkg/apis/query/v0alpha1"
+	query "github.com/grafana/grafana/pkg/apis/query/v0alpha1"
 )
 
 func TestParseQueriesIntoQueryDataRequest(t *testing.T) {
@@ -39,23 +40,23 @@ func TestParseQueriesIntoQueryDataRequest(t *testing.T) {
 		"to": "1692646267389"
 	}`)
 
-	req := &v0alpha1.GenericQueryRequest{}
+	req := &query.QueryDataRequest{}
 	err := json.Unmarshal(request, req)
 	require.NoError(t, err)
 
 	require.Len(t, req.Queries, 2)
 	require.Equal(t, "b1808c48-9fc9-4045-82d7-081781f8a553", req.Queries[0].Datasource.UID)
-	require.Equal(t, "spreadsheetID", req.Queries[0].AdditionalProperties()["spreadsheet"])
+	require.Equal(t, "spreadsheetID", req.Queries[0].GetString("spreadsheet"))
 
 	// Write the query (with additional spreadsheetID) to JSON
 	out, err := json.MarshalIndent(req.Queries[0], "", "  ")
 	require.NoError(t, err)
 
 	// And read it back with standard JSON marshal functions
-	query := &v0alpha1.GenericDataQuery{}
+	query := &data.DataQuery{}
 	err = json.Unmarshal(out, query)
 	require.NoError(t, err)
-	require.Equal(t, "spreadsheetID", query.AdditionalProperties()["spreadsheet"])
+	require.Equal(t, "spreadsheetID", query.GetString("spreadsheet"))
 
 	// The second query has an explicit time range, and legacy datasource name
 	out, err = json.MarshalIndent(req.Queries[1], "", "  ")

pkg/apis/query/v0alpha1/register.go

@@ -19,6 +19,12 @@ var DataSourceApiServerResourceInfo = common.NewResourceInfo(GROUP, VERSION,
 	func() runtime.Object { return &DataSourceApiServerList{} },
 )
 
+var QueryTypeDefinitionResourceInfo = common.NewResourceInfo(GROUP, VERSION,
+	"querytypes", "querytype", "QueryTypeDefinition",
+	func() runtime.Object { return &QueryTypeDefinition{} },
+	func() runtime.Object { return &QueryTypeDefinitionList{} },
+)
+
 var (
 	// SchemeGroupVersion is group version used to register these objects
 	SchemeGroupVersion = schema.GroupVersion{Group: GROUP, Version: VERSION}