remove all duplicated logic, move all macroses and query parsing functionality to golang, and compile golang parser to WASM

go.mod

@@ -6,13 +6,15 @@ require (
 	github.com/andybalholm/brotli v1.1.1
 	github.com/dlclark/regexp2 v1.11.4
 	github.com/grafana/grafana-plugin-sdk-go v0.260.1
+	github.com/hyperjumptech/jiffy v1.0.0
 	github.com/klauspost/compress v1.17.11
 	github.com/stretchr/testify v1.10.0
 	golang.org/x/sync v0.9.0
 )
 
 require (
 	github.com/BurntSushi/toml v1.4.0 // indirect
+	github.com/antlr/antlr4 v0.0.0-20200124162019-2d7f727a00b7 // indirect
 	github.com/apache/arrow/go/v15 v15.0.2 // indirect
 	github.com/beorn7/perks v1.0.1 // indirect
 	github.com/cenkalti/backoff/v4 v4.3.0 // indirect
@@ -53,7 +55,6 @@ require (
 	github.com/mattn/go-colorable v0.1.13 // indirect
 	github.com/mattn/go-isatty v0.0.20 // indirect
 	github.com/mattn/go-runewidth v0.0.16 // indirect
-	github.com/mitchellh/go-testing-interface v1.14.1 // indirect
 	github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect
 	github.com/modern-go/reflect2 v1.0.2 // indirect
 	github.com/mohae/deepcopy v0.0.0-20170929034955-c48cc78d4826 // indirect

package.json

@@ -63,19 +63,14 @@
     "node": ">=16"
   },
   "dependencies": {
-    "@emotion/css": "^11.1.3",
     "@grafana/data": "11.3.0",
     "@grafana/runtime": "11.3.0",
     "@grafana/ui": "11.3.0",
     "date-fns": "^4.1.0",
     "date-fns-tz": "^3.2.0",
-    "dayjs": "^1.11.13",
-    "jest-resolve": "^29.7.0",
-    "lodash-es": "^4.17.21",
     "luxon": "^3.5.0",
     "react": "18.3.0",
-    "react-dom": "18.3.0",
-    "tslib": "2.5.3"
+    "react-dom": "18.3.0"
   },
   "packageManager": "[email protected]"
 }

pkg/datasource.go

@@ -1,24 +1,49 @@
 package main
 
 import (
+	"context"
 	"encoding/json"
 	"fmt"
-	"golang.org/x/sync/errgroup"
-
-	"context"
 	"github.com/grafana/grafana-plugin-sdk-go/backend"
 	"github.com/grafana/grafana-plugin-sdk-go/backend/datasource"
 	"github.com/grafana/grafana-plugin-sdk-go/backend/instancemgmt"
+	"github.com/grafana/grafana-plugin-sdk-go/backend/resource/httpadapter"
+	"golang.org/x/sync/errgroup"
+	"net/http"
 )
 
+func newResourceHandler() backend.CallResourceHandler {
+	mux := http.NewServeMux()
+	mux.HandleFunc("/replace", func(w http.ResponseWriter, r *http.Request) {
+		replaceQuery(w, r)
+	})
+	mux.HandleFunc("/get-ast-property", func(w http.ResponseWriter, r *http.Request) {
+		getAstProperty(w, r)
+	})
+	mux.HandleFunc("/get-ast", func(w http.ResponseWriter, r *http.Request) {
+		getCompleteAst(w, r)
+	})
+	mux.HandleFunc("/apply-adhoc-filters", func(w http.ResponseWriter, r *http.Request) {
+		applyAdhocFilters(w, r)
+	})
+	mux.HandleFunc("/replace-time-filters", func(w http.ResponseWriter, r *http.Request) {
+		replaceTimeFilters(w, r)
+	})
+	mux.HandleFunc("/create-query", func(w http.ResponseWriter, r *http.Request) {
+		createQuery(w, r)
+	})
+	return httpadapter.New(mux)
+}
+
 func GetDatasourceServeOpts() datasource.ServeOpts {
 	ds := &ClickHouseDatasource{
 		im: datasource.NewInstanceManager(NewDatasourceSettings),
 	}
 
 	return datasource.ServeOpts{
-		QueryDataHandler:   ds,
-		CheckHealthHandler: ds,
+		QueryDataHandler:    ds,
+		CheckHealthHandler:  ds,
+		CallResourceHandler: newResourceHandler(),
 	}
 }
 

pkg/eval_query.go

@@ -2,12 +2,14 @@ package main
 
 import (
 	"fmt"
+	"github.com/dlclark/regexp2"
+	"github.com/hyperjumptech/jiffy"
 	"math"
 	"regexp"
+	"strconv"
 	"strings"
 	"time"
-
-	"github.com/dlclark/regexp2"
+	"unicode"
 )
 
 /* var NumberOnlyRegexp = regexp.MustCompile(`^[+-]?\d+(\.\d+)?$`) */
@@ -51,10 +53,64 @@ type EvalQuery struct {
 	Database               string `json:"database"`
 	Table                  string `json:"table"`
 	MaxDataPoints          int64
+	FrontendDatasource     bool `json:"frontendDatasource"`
 	From                   time.Time
 	To                     time.Time
 }
 
+func parseInterval(interval string, intervalFactor int) (int, int, error) {
+	// Parse the duration
+	dur, err := jiffy.DurationOf(interval)
+	if err != nil {
+		return 0, 0, err
+	}
+
+	// Describe the duration (for a formatted string output)
+	durationSeconds := strings.Map(func(r rune) rune {
+		if unicode.IsDigit(r) {
+			return r
+		}
+		return -1
+	}, jiffy.DescribeDuration(dur, &jiffy.Want{
+		Second:      true,
+		Millisecond: false,
+		Verbose:     false,
+	}))
+
+	durationMilliseconds := strings.Map(func(r rune) rune {
+		if unicode.IsDigit(r) {
+			return r
+		}
+		return -1
+	}, jiffy.DescribeDuration(dur, &jiffy.Want{
+		Second:      false,
+		Millisecond: true,
+		Verbose:     false,
+	}))
+
+	var seconds, milliseconds int
+	// Calculate seconds and milliseconds
+	if durationSeconds != "" {
+		seconds, err = strconv.Atoi(durationSeconds)
+		if err != nil {
+			return 0, 0, err
+		}
+	}
+
+	if durationMilliseconds != "" {
+		milliseconds, err = strconv.Atoi(durationMilliseconds)
+		if err != nil {
+			return 0, 0, err
+		}
+	}
+
+	if seconds == 0 {
+		seconds = 1
+	}
+
+	return seconds * intervalFactor, milliseconds * intervalFactor, nil
+}
+
 func (q *EvalQuery) ApplyMacrosAndTimeRangeToQuery() (string, error) {
 	query, err := q.replace(q.Query)
 	if err != nil {
@@ -76,12 +132,12 @@ func (q *EvalQuery) replace(query string) (string, error) {
 	i := 1 * time.Second
 	ms := 1 * time.Millisecond
 	if q.Interval != "" {
-		duration, err := time.ParseDuration(q.Interval)
+		intervalSeconds, intervalMs, err := parseInterval(q.Interval, q.IntervalFactor)
 		if err != nil {
 			return "", err
 		}
-		q.IntervalSec = int(math.Ceil(duration.Seconds()))
-		q.IntervalMs = int(duration.Milliseconds())
+		q.IntervalSec = intervalSeconds
+		q.IntervalMs = intervalMs
 	}
 	if q.IntervalSec <= 0 {
 		if q.MaxDataPoints > 0 {
@@ -322,15 +378,15 @@ func (q *EvalQuery) applyMacros(query string, ast *EvalAST) (string, error) {
 	if q.contain(ast, "$perSecondColumnsAggregated") {
 		return q.perSecondColumnsAggregated(query, ast)
 	}
-	if q.contain(ast, "$deltaColumnsAggregated") {
-		return q.deltaColumnsAggregated(query, ast)
-	}
 	if q.contain(ast, "$delta") {
 		return q.delta(query, ast)
 	}
 	if q.contain(ast, "$deltaColumns") {
 		return q.deltaColumns(query, ast)
 	}
+	if q.contain(ast, "$deltaColumnsAggregated") {
+		return q.deltaColumnsAggregated(query, ast)
+	}
 	if q.contain(ast, "$increase") {
 		return q.increase(query, ast)
 	}
@@ -1203,7 +1259,12 @@ func (q *EvalQuery) round(dt time.Time, round int) time.Time {
 	if round == 0 {
 		return dt
 	}
-	return dt.Truncate(time.Duration(round) * time.Second)
+
+	// Round to the nearest multiple of `round` seconds
+	coefficient := round
+	rounded := time.Unix(dt.Unix()/int64(coefficient)*int64(coefficient), 0)
+
+	return rounded
 }
 
 func (q *EvalQuery) convertInterval(interval string, intervalFactor int, ms bool) (int, error) {
@@ -1217,6 +1278,7 @@ func (q *EvalQuery) convertInterval(interval string, intervalFactor int, ms bool
 	if ms {
 		return int(math.Ceil(float64(d.Milliseconds()) * float64(intervalFactor))), nil
 	}
+
 	return int(math.Ceil(d.Seconds() * float64(intervalFactor))), nil
 }
 
@@ -1708,6 +1770,9 @@ func (s *EvalQueryScanner) RemoveComments(query string) (string, error) {
 }
 
 func (s *EvalQueryScanner) AddMetadata(query string, q *EvalQuery) string {
+	if q.FrontendDatasource {
+		return "/* grafana dashboard=$__dashboard, user=$__user */\n" + query
+	}
 	return "/* grafana alerts rule=" + q.RuleUid + " query=" + q.RefId + " */ " + query
 }
 
@@ -2145,7 +2210,7 @@ func printAST(AST *EvalAST, tab string) string {
 		result += printItems(AST.Obj["prewhere"].(*EvalAST), tab, "")
 	}
 
-	if AST.hasOwnProperty("where") {
+	if AST.hasOwnProperty("where") && len(AST.Obj["where"].(*EvalAST).Arr) > 0 {
 		result += newLine + tab + "WHERE"
 		result += printItems(AST.Obj["where"].(*EvalAST), tab, "")
 	}