Experimental: Add query type definition and schemas

apis/data/v0alpha1/client.go

@@ -0,0 +1,66 @@
+package v0alpha1
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"fmt"
+	"net/http"
+
+	"github.com/grafana/grafana-plugin-sdk-go/backend"
+	"github.com/grafana/grafana-plugin-sdk-go/data/utils/jsoniter"
+)
+
+type QueryDataClient interface {
+	QueryData(ctx context.Context, req QueryDataRequest, headers ...string) (int, *backend.QueryDataResponse, error)
+}
+
+type simpleHTTPClient struct {
+	url     string
+	client  *http.Client
+	headers []string
+}
+
+func NewQueryDataClient(url string, client *http.Client, headers ...string) QueryDataClient {
+	if client == nil {
+		client = http.DefaultClient
+	}
+	return &simpleHTTPClient{
+		url:     url,
+		client:  client,
+		headers: headers,
+	}
+}
+
+func (c *simpleHTTPClient) QueryData(ctx context.Context, query QueryDataRequest, headers ...string) (int, *backend.QueryDataResponse, error) {
+	body, err := json.Marshal(query)
+	if err != nil {
+		return http.StatusBadRequest, nil, err
+	}
+
+	req, err := http.NewRequestWithContext(ctx, http.MethodPost, c.url, bytes.NewBuffer(body))
+	if err != nil {
+		return http.StatusBadRequest, nil, err
+	}
+	headers = append(c.headers, headers...)
+	if (len(headers) % 2) != 0 {
+		return http.StatusBadRequest, nil, fmt.Errorf("headers must be in pairs of two")
+	}
+	for i := 0; i < len(headers); i += 2 {
+		req.Header.Set(headers[i], headers[i+1])
+	}
+	req.Header.Set("Content-Type", "application/json")
+
+	rsp, err := c.client.Do(req)
+	if err != nil {
+		return rsp.StatusCode, nil, err
+	}
+	defer rsp.Body.Close()
+
+	qdr := &backend.QueryDataResponse{}
+	iter, err := jsoniter.Parse(jsoniter.ConfigCompatibleWithStandardLibrary, rsp.Body, 1024*10)
+	if err == nil {
+		err = iter.ReadVal(qdr)
+	}
+	return rsp.StatusCode, qdr, err
+}

apis/data/v0alpha1/client_test.go

@@ -0,0 +1,52 @@
+package v0alpha1_test
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"testing"
+
+	"github.com/grafana/grafana-plugin-sdk-go/apis/data/v0alpha1"
+	"github.com/stretchr/testify/require"
+)
+
+func TestQueryClient(t *testing.T) {
+	t.Skip()
+
+	client := v0alpha1.NewQueryDataClient("http://localhost:3000/api/ds/query", nil,
+		"Authorization", "Bearer YOURKEYHERE",
+	)
+	body := `{
+		"from": "",
+		"to": "",
+		"queries": [
+			{
+				"refId": "X",
+				"scenarioId": "csv_content",
+				"datasource": {
+					"type": "grafana-testdata-datasource",
+					"uid": "PD8C576611E62080A"
+				},
+				"csvContent": "a,b,c\n1,hello,true",
+				"hide": true
+			}
+		]
+	}`
+	qdr := v0alpha1.QueryDataRequest{}
+	err := json.Unmarshal([]byte(body), &qdr)
+	require.NoError(t, err)
+
+	code, rsp, err := client.QueryData(context.Background(), qdr)
+	require.NoError(t, err)
+	require.Equal(t, http.StatusOK, code)
+
+	r, ok := rsp.Responses["X"]
+	require.True(t, ok)
+
+	for _, frame := range r.Frames {
+		txt, err := frame.StringTable(20, 10)
+		require.NoError(t, err)
+		fmt.Printf("%s\n", txt)
+	}
+}

apis/sdkapi/v0alpha1/openapi.go → apis/data/v0alpha1/openapi.go

@@ -12,10 +12,10 @@ var f embed.FS
 
 func GetOpenAPIDefinitions(ref common.ReferenceCallback) map[string]common.OpenAPIDefinition {
 	return map[string]common.OpenAPIDefinition{
-		"github.com/grafana/grafana-plugin-sdk-go/backend.DataResponse":                         schemaDataResponse(ref),
-		"github.com/grafana/grafana-plugin-sdk-go/data.Frame":                                   schemaDataFrame(ref),
-		"github.com/grafana/grafana-plugin-sdk-go/apis/sdkapi/v0alpha1.DataQuery":               schemaDataQuery(ref),
-		"github.com/grafana/grafana-plugin-sdk-go/apis/sdkapi/v0alpha1.QueryTypeDefinitionSpec": schemaQueryTypeDefinitionSpec(ref),
+		"github.com/grafana/grafana-plugin-sdk-go/backend.DataResponse":                       schemaDataResponse(ref),
+		"github.com/grafana/grafana-plugin-sdk-go/data.Frame":                                 schemaDataFrame(ref),
+		"github.com/grafana/grafana-plugin-sdk-go/apis/data/v0alpha1.DataQuery":               schemaDataQuery(ref),
+		"github.com/grafana/grafana-plugin-sdk-go/apis/data/v0alpha1.QueryTypeDefinitionSpec": schemaQueryTypeDefinitionSpec(ref),
 	}
 }
 

apis/sdkapi/v0alpha1/query.go → apis/data/v0alpha1/query.go

@@ -16,7 +16,7 @@ func init() { //nolint:gochecknoinits
 	jsoniter.RegisterTypeDecoder("v0alpha1.DataQuery", &genericQueryCodec{})
 }
 
-type DataQueryRequest struct {
+type QueryDataRequest struct {
 	// Time range applied to each query (when not included in the query body)
 	TimeRange `json:",inline"`
 

apis/sdkapi/v0alpha1/query_test.go → apis/data/v0alpha1/query_test.go

@@ -36,7 +36,7 @@ func TestParseQueriesIntoQueryDataRequest(t *testing.T) {
 		"to": "1692646267389"
 	}`)
 
-	req := &DataQueryRequest{}
+	req := &QueryDataRequest{}
 	err := json.Unmarshal(request, req)
 	require.NoError(t, err)
 
@@ -74,7 +74,7 @@ func TestParseQueriesIntoQueryDataRequest(t *testing.T) {
 	})
 
 	t.Run("same results from either parser", func(t *testing.T) {
-		typed := &DataQueryRequest{}
+		typed := &QueryDataRequest{}
 		err = json.Unmarshal(request, typed)
 		require.NoError(t, err)
 

experimental/schemabuilder/example/query_test.go

@@ -4,7 +4,7 @@ import (
 	"reflect"
 	"testing"
 
-	sdkapi "github.com/grafana/grafana-plugin-sdk-go/apis/sdkapi/v0alpha1"
+	data "github.com/grafana/grafana-plugin-sdk-go/apis/data/v0alpha1"
 	"github.com/grafana/grafana-plugin-sdk-go/experimental/schemabuilder"
 	"github.com/stretchr/testify/require"
 )
@@ -23,30 +23,30 @@ func TestQueryTypeDefinitions(t *testing.T) {
 	})
 	require.NoError(t, err)
 	err = builder.AddQueries(schemabuilder.QueryTypeInfo{
-		Discriminators: sdkapi.NewDiscriminators("queryType", QueryTypeMath),
+		Discriminators: data.NewDiscriminators("queryType", QueryTypeMath),
 		GoType:         reflect.TypeOf(&MathQuery{}),
-		Examples: []sdkapi.QueryExample{
+		Examples: []data.QueryExample{
 			{
 				Name: "constant addition",
-				SaveModel: sdkapi.AsUnstructured(MathQuery{
+				SaveModel: data.AsUnstructured(MathQuery{
 					Expression: "$A + 11",
 				}),
 			},
 			{
 				Name: "math with two queries",
-				SaveModel: sdkapi.AsUnstructured(MathQuery{
+				SaveModel: data.AsUnstructured(MathQuery{
 					Expression: "$A - $B",
 				}),
 			},
 		},
 	},
 		schemabuilder.QueryTypeInfo{
-			Discriminators: sdkapi.NewDiscriminators("queryType", QueryTypeReduce),
+			Discriminators: data.NewDiscriminators("queryType", QueryTypeReduce),
 			GoType:         reflect.TypeOf(&ReduceQuery{}),
-			Examples: []sdkapi.QueryExample{
+			Examples: []data.QueryExample{
 				{
 					Name: "get max value",
-					SaveModel: sdkapi.AsUnstructured(ReduceQuery{
+					SaveModel: data.AsUnstructured(ReduceQuery{
 						Expression: "$A",
 						Reducer:    ReducerMax,
 						Settings: ReduceSettings{
@@ -57,9 +57,9 @@ func TestQueryTypeDefinitions(t *testing.T) {
 			},
 		},
 		schemabuilder.QueryTypeInfo{
-			Discriminators: sdkapi.NewDiscriminators("queryType", QueryTypeResample),
+			Discriminators: data.NewDiscriminators("queryType", QueryTypeResample),
 			GoType:         reflect.TypeOf(&ResampleQuery{}),
-			Examples:       []sdkapi.QueryExample{},
+			Examples:       []data.QueryExample{},
 		})
 	require.NoError(t, err)
 

experimental/schemabuilder/examples.go

@@ -1,22 +1,22 @@
 package schemabuilder
 
 import (
-	sdkapi "github.com/grafana/grafana-plugin-sdk-go/apis/sdkapi/v0alpha1"
+	data "github.com/grafana/grafana-plugin-sdk-go/apis/data/v0alpha1"
 )
 
-func exampleRequest(defs sdkapi.QueryTypeDefinitionList) sdkapi.DataQueryRequest {
-	rsp := sdkapi.DataQueryRequest{
-		TimeRange: sdkapi.TimeRange{
+func exampleRequest(defs data.QueryTypeDefinitionList) data.QueryDataRequest {
+	rsp := data.QueryDataRequest{
+		TimeRange: data.TimeRange{
 			From: "now-1h",
 			To:   "now",
 		},
-		Queries: []sdkapi.DataQuery{},
+		Queries: []data.DataQuery{},
 	}
 
 	for _, def := range defs.Items {
 		for _, sample := range def.Spec.Examples {
 			if sample.SaveModel.Object != nil {
-				q := sdkapi.NewDataQuery(sample.SaveModel.Object)
+				q := data.NewDataQuery(sample.SaveModel.Object)
 				q.RefID = string(rune('A' + len(rsp.Queries)))
 				for _, dis := range def.Spec.Discriminators {
 					_ = q.Set(dis.Field, dis.Value)
@@ -36,13 +36,13 @@ func exampleRequest(defs sdkapi.QueryTypeDefinitionList) sdkapi.DataQueryRequest
 	return rsp
 }
 
-func examplePanelTargets(ds *sdkapi.DataSourceRef, defs sdkapi.QueryTypeDefinitionList) []sdkapi.DataQuery {
-	targets := []sdkapi.DataQuery{}
+func examplePanelTargets(ds *data.DataSourceRef, defs data.QueryTypeDefinitionList) []data.DataQuery {
+	targets := []data.DataQuery{}
 
 	for _, def := range defs.Items {
 		for _, sample := range def.Spec.Examples {
 			if sample.SaveModel.Object != nil {
-				q := sdkapi.NewDataQuery(sample.SaveModel.Object)
+				q := data.NewDataQuery(sample.SaveModel.Object)
 				q.Datasource = ds
 				q.RefID = string(rune('A' + len(targets)))
 				for _, dis := range def.Spec.Discriminators {

experimental/schemabuilder/panel.go

@@ -1,6 +1,6 @@
 package schemabuilder
 
-import sdkapi "github.com/grafana/grafana-plugin-sdk-go/apis/sdkapi/v0alpha1"
+import sdkapi "github.com/grafana/grafana-plugin-sdk-go/apis/data/v0alpha1"
 
 // This is only used to write out a sample panel query
 // It is not public and not intended to represent a real panel

experimental/schemabuilder/reflector.go

@@ -11,7 +11,7 @@ import (
 
 	"github.com/google/go-cmp/cmp"
 	"github.com/google/go-cmp/cmp/cmpopts"
-	sdkapi "github.com/grafana/grafana-plugin-sdk-go/apis/sdkapi/v0alpha1"
+	sdkapi "github.com/grafana/grafana-plugin-sdk-go/apis/data/v0alpha1"
 	"github.com/grafana/grafana-plugin-sdk-go/data"
 	"github.com/invopop/jsonschema"
 	"github.com/stretchr/testify/assert"

experimental/schemabuilder/reflector_test.go

@@ -5,7 +5,7 @@ import (
 	"reflect"
 	"testing"
 
-	sdkapi "github.com/grafana/grafana-plugin-sdk-go/apis/sdkapi/v0alpha1"
+	sdkapi "github.com/grafana/grafana-plugin-sdk-go/apis/data/v0alpha1"
 	"github.com/grafana/grafana-plugin-sdk-go/data"
 	"github.com/invopop/jsonschema"
 	"github.com/stretchr/testify/require"
@@ -16,8 +16,8 @@ func TestWriteQuerySchema(t *testing.T) {
 		PluginID: []string{"dummy"},
 		ScanCode: []CodePaths{
 			{
-				BasePackage: "github.com/grafana/grafana-plugin-sdk-go/apis/sdkapi",
-				CodePath:    "../../apis/sdkapi/v0alpha1",
+				BasePackage: "github.com/grafana/grafana-plugin-sdk-go/apis/data",
+				CodePath:    "../../apis/data/v0alpha1",
 			},
 			{
 				BasePackage: "github.com/grafana/grafana-plugin-sdk-go/data",
@@ -40,7 +40,7 @@ func TestWriteQuerySchema(t *testing.T) {
 	// // Hide this old property
 	query.Properties.Delete("datasourceId")
 
-	outfile := "../../apis/sdkapi/v0alpha1/query.schema.json"
+	outfile := "../../apis/data/v0alpha1/query.schema.json"
 	old, _ := os.ReadFile(outfile)
 	maybeUpdateFile(t, outfile, query, old)
 
@@ -54,10 +54,10 @@ func TestWriteQuerySchema(t *testing.T) {
 	updateEnumDescriptions(query)
 	query.ID = ""
 	query.Version = draft04 // used by kube-openapi
-	outfile = "../../apis/sdkapi/v0alpha1/query.definition.schema.json"
+	outfile = "../../apis/data/v0alpha1/query.definition.schema.json"
 	old, _ = os.ReadFile(outfile)
 	maybeUpdateFile(t, outfile, query, old)
 
-	def := sdkapi.GetOpenAPIDefinitions(nil)["github.com/grafana/grafana-plugin-sdk-go/apis/sdkapi/v0alpha1.QueryTypeDefinitionSpec"]
+	def := sdkapi.GetOpenAPIDefinitions(nil)["github.com/grafana/grafana-plugin-sdk-go/apis/data/v0alpha1.QueryTypeDefinitionSpec"]
 	require.Equal(t, query.Properties.Len(), len(def.Schema.Properties))
 }

experimental/schemabuilder/schema.go

@@ -4,7 +4,7 @@ import (
 	"encoding/json"
 	"fmt"
 
-	sdkapi "github.com/grafana/grafana-plugin-sdk-go/apis/sdkapi/v0alpha1"
+	sdkapi "github.com/grafana/grafana-plugin-sdk-go/apis/data/v0alpha1"
 	"k8s.io/kube-openapi/pkg/validation/spec"
 )