feat: view query plan as a json

router/cmd/plan_generator.go

@@ -36,6 +36,7 @@ func PlanGenerator(args []string) {
 	f.BoolVar(&cfg.FailOnPlanError, "fail-on-error", false, "if at least one plan fails, the command exit code will be 1")
 	f.BoolVar(&cfg.FailFast, "fail-fast", false, "stop as soon as possible if a plan fails")
 	f.StringVar(&cfg.LogLevel, "log-level", "warn", "log level to use (debug, info, warn, error, panic, fatal)")
+	f.BoolVar(&cfg.Raw, "raw", false, "get the raw json output of the plan generator")
 	f.UintVar(&cfg.MaxDataSourceCollectorsConcurrency, "max-collectors", 0, "max number of concurrent data source collectors, if unset or 0, no limit will be enforced")
 
 	if err := f.Parse(args[1:]); err != nil {

router/core/plan_generator.go

@@ -2,6 +2,7 @@ package core
 
 import (
 	"context"
+	"encoding/json"
 	"errors"
 	"fmt"
 	"net/http"
@@ -65,7 +66,7 @@ func NewPlanner(planConfiguration *plan.Configuration, definition *ast.Document,
 	}, nil
 }
 
-func (pl *Planner) PlanOperation(operationFilePath string) (string, error) {
+func (pl *Planner) PlanOperation(operationFilePath string, rawQueryPlan bool) (string, error) {
 	operation, err := pl.parseOperation(operationFilePath)
 	if err != nil {
 		return "", &PlannerOperationValidationError{err: err}
@@ -91,6 +92,13 @@ func (pl *Planner) PlanOperation(operationFilePath string) (string, error) {
 		return "", fmt.Errorf("failed to plan operation: %w", err)
 	}
 
+	if rawQueryPlan {
+		marshal, err := json.Marshal(rawPlan)
+		if err != nil {
+			return "", fmt.Errorf("failed to marshal raw plan: %w", err)
+		}
+		return string(marshal), nil
+	}
 	return rawPlan.PrettyPrint(), nil
 }
 

router/pkg/plan_generator/plan_generator.go

@@ -30,6 +30,7 @@ type QueryPlanConfig struct {
 	OutputReport                       bool
 	FailOnPlanError                    bool
 	FailFast                           bool
+	Raw                                bool
 	LogLevel                           string
 	Logger                             *zap.Logger
 	MaxDataSourceCollectorsConcurrency uint
@@ -140,9 +141,13 @@ func PlanGenerator(ctx context.Context, cfg QueryPlanConfig) error {
 
 					queryFilePath := filepath.Join(queriesPath, queryFile.Name())
 
-					outContent, err := planner.PlanOperation(queryFilePath)
+					outContent, err := planner.PlanOperation(queryFilePath, cfg.Raw)
+					fileName := queryFile.Name()
+					if cfg.Raw {
+						fileName += ".json"
+					}
 					res := QueryPlanResult{
-						FileName: queryFile.Name(),
+						FileName: fileName,
 						Plan:     outContent,
 					}
 					if err != nil {
@@ -160,7 +165,7 @@ func PlanGenerator(ctx context.Context, cfg QueryPlanConfig) error {
 					}
 
 					if cfg.OutputFiles {
-						outFileName := filepath.Join(outPath, queryFile.Name())
+						outFileName := filepath.Join(outPath, fileName)
 						err = os.WriteFile(outFileName, []byte(outContent), 0644)
 						if err != nil {
 							cancelError(fmt.Errorf("failed to write file: %v", err))

router/pkg/plan_generator/plan_generator_test.go

@@ -331,4 +331,107 @@ func TestPlanGenerator(t *testing.T) {
 		assert.NoError(t, err)
 		assert.Equal(t, errMsg, writtenResults.Error)
 	})
+
+	t.Run("generates raw json plans when Raw is enabled", func(t *testing.T) {
+		tempDir, err := os.MkdirTemp("", "plans-")
+		require.NoError(t, err)
+		defer func() {
+			_ = os.RemoveAll(tempDir)
+		}()
+
+		cfg := QueryPlanConfig{
+			SourceDir:       path.Join(getTestDataDir(), "queries", "base"),
+			OutDir:          tempDir,
+			ExecutionConfig: path.Join(getTestDataDir(), "execution_config", "base.json"),
+			Timeout:         "30s",
+			OutputFiles:     true,
+			Raw:             true,
+		}
+
+		err = PlanGenerator(context.Background(), cfg)
+		assert.NoError(t, err)
+
+		entriesInOutDir, err := os.ReadDir(tempDir)
+		assert.NoError(t, err)
+		assert.Len(t, entriesInOutDir, len(allFiles))
+
+		for _, de := range entriesInOutDir {
+			name := de.Name()
+			content, err := os.ReadFile(path.Join(tempDir, name))
+			assert.NoError(t, err)
+			var m map[string]interface{}
+
+			// One of the queries produces a failed result
+			if err := json.Unmarshal(content, &m); err != nil {
+				assert.True(t, strings.HasPrefix(string(content), "Warning:"))
+			} else {
+				assert.NotEmpty(t, m)
+			}
+		}
+	})
+
+	t.Run("report file uses .json filenames when Raw is enabled", func(t *testing.T) {
+		tempDir, err := os.MkdirTemp("", "plans-")
+		require.NoError(t, err)
+		defer func() {
+			_ = os.RemoveAll(tempDir)
+		}()
+
+		cfg := QueryPlanConfig{
+			SourceDir:       path.Join(getTestDataDir(), "queries", "base"),
+			OutDir:          tempDir,
+			ExecutionConfig: path.Join(getTestDataDir(), "execution_config", "base.json"),
+			Timeout:         "30s",
+			OutputReport:    true,
+			Raw:             true,
+		}
+
+		err = PlanGenerator(context.Background(), cfg)
+		assert.NoError(t, err)
+
+		results, err := os.ReadFile(path.Join(tempDir, ReportFileName))
+		assert.NoError(t, err)
+		var writtenResults QueryPlanResults
+		assert.NoError(t, json.Unmarshal(results, &writtenResults))
+		assert.Len(t, writtenResults.Plans, len(allFiles))
+		for _, pr := range writtenResults.Plans {
+			assert.True(t, strings.HasSuffix(pr.FileName, ".json"))
+		}
+	})
+
+	t.Run("generates non-raw textual plans when Raw is disabled", func(t *testing.T) {
+		tempDir, err := os.MkdirTemp("", "plans-")
+		require.NoError(t, err)
+		defer func() {
+			_ = os.RemoveAll(tempDir)
+		}()
+
+		cfg := QueryPlanConfig{
+			SourceDir:       path.Join(getTestDataDir(), "queries", "base"),
+			OutDir:          tempDir,
+			ExecutionConfig: path.Join(getTestDataDir(), "execution_config", "base.json"),
+			Timeout:         "30s",
+			OutputFiles:     true,
+		}
+
+		err = PlanGenerator(context.Background(), cfg)
+		assert.NoError(t, err)
+
+		entriesInOutDir, err := os.ReadDir(tempDir)
+		assert.NoError(t, err)
+		assert.Len(t, entriesInOutDir, len(allFiles))
+
+		for _, de := range entriesInOutDir {
+			name := de.Name()
+			assert.True(t, strings.HasSuffix(name, ".graphql"))
+			content, err := os.ReadFile(path.Join(tempDir, name))
+			assert.NoError(t, err)
+			var m map[string]interface{}
+			assert.Error(t, json.Unmarshal(content, &m))
+			// Should be textual query plan or warning
+			s := string(content)
+			assert.True(t, strings.HasPrefix(s, "QueryPlan {") || strings.HasPrefix(s, "Warning:"))
+		}
+	})
+
 }