add new command for connector, and regenerate console.json

cmd/multiple_flags.go

@@ -1,6 +1,8 @@
 package cmd
 
 import (
+	"encoding/json"
+	"fmt"
 	"strconv"
 
 	"github.com/conduktor/ctl/internal/utils"
@@ -31,6 +33,10 @@ func NewMultipleFlags(command *cobra.Command, flagParams map[string]schema.FlagP
 			isFlagSet = true
 			defaultValue := 0
 			result[key] = command.Flags().Int(flag.FlagName, defaultValue, usage)
+		} else if flag.Type == "json" {
+			isFlagSet = true
+			defaultValue := ""
+			result[key] = command.Flags().String(flag.FlagName, defaultValue, "JSON value")
 		} else if utils.CdkDebug() {
 			println("Unknown flag type: " + flag.Type)
 		}
@@ -46,14 +52,26 @@ func NewMultipleFlags(command *cobra.Command, flagParams map[string]schema.FlagP
 	}
 }
 
-func (m *MultipleFlags) ExtractFlagValueForBodyParam() map[string]interface{} {
+func (m *MultipleFlags) ExtractFlagValueForBodyParam() (map[string]interface{}, error) {
 	bodyParams := make(map[string]interface{})
 	for key, value := range m.result {
 		if value != nil && m.flagSetByUser(key) {
-			bodyParams[key] = value
+			if m.flagParams[key].Type == "json" {
+				str, ok := value.(*string)
+				if !ok {
+					panic("Expected json flag " + key + " to be a *string")
+				}
+				var decoded interface{}
+				if err := json.Unmarshal([]byte(*str), &decoded); err != nil {
+					return nil, fmt.Errorf("invalid JSON for flag --%s: %w", m.flagParams[key].FlagName, err)
+				}
+				bodyParams[key] = decoded
+			} else {
+				bodyParams[key] = value
+			}
 		}
 	}
-	return bodyParams
+	return bodyParams, nil
 }
 
 func (m *MultipleFlags) ExtractFlagValueForQueryParam() map[string]string {

cmd/multiple_flags_test.go

@@ -68,6 +68,9 @@ func TestExtractFlagValueForBodyParam(t *testing.T) {
 		"intParam":       {FlagName: "intParam", Type: "integer"},
 		"notSetInt":      {FlagName: "notSetInt", Type: "integer"},
 		"zeroParam":      {FlagName: "zeroParam", Type: "integer"},
+		"jsonArray":      {FlagName: "jsonArray", Type: "json"},
+		"jsonObject":     {FlagName: "jsonObject", Type: "json"},
+		"notSetJson":     {FlagName: "notSetJson", Type: "json"},
 	})
 	multipleFlags.result = map[string]interface{}{
 		"stringParam":    func() *string { s := "test"; return &s }(),
@@ -79,6 +82,9 @@ func TestExtractFlagValueForBodyParam(t *testing.T) {
 		"intParam":       func() *int { i := 123; return &i }(),
 		"notSetInt":      func() *int { i := 0; return &i }(),
 		"zeroParam":      func() *int { i := 0; return &i }(),
+		"jsonArray":      func() *string { s := `[{"partition":1,"offset":42}]`; return &s }(),
+		"jsonObject":     func() *string { s := `{"key":"value"}`; return &s }(),
+		"notSetJson":     func() *string { s := ""; return &s }(),
 	}
 
 	expected := map[string]interface{}{
@@ -88,6 +94,8 @@ func TestExtractFlagValueForBodyParam(t *testing.T) {
 		"boolParamFalse": func() *bool { b := false; return &b }(),
 		"intParam":       func() *int { i := 123; return &i }(),
 		"zeroParam":      func() *int { i := 0; return &i }(),
+		"jsonArray":      []interface{}{map[string]interface{}{"partition": float64(1), "offset": float64(42)}},
+		"jsonObject":     map[string]interface{}{"key": "value"},
 	}
 
 	command.Flags().Lookup("stringParam").Changed = true
@@ -96,9 +104,30 @@ func TestExtractFlagValueForBodyParam(t *testing.T) {
 	command.Flags().Lookup("intParam").Changed = true
 	command.Flags().Lookup("zeroParam").Changed = true
 	command.Flags().Lookup("emptyString").Changed = true
-	result := multipleFlags.ExtractFlagValueForBodyParam()
+	command.Flags().Lookup("jsonArray").Changed = true
+	command.Flags().Lookup("jsonObject").Changed = true
+	result, err := multipleFlags.ExtractFlagValueForBodyParam()
+	if err != nil {
+		t.Fatalf("unexpected error: %s", err)
+	}
 
 	if !reflect.DeepEqual(result, expected) {
 		t.Error(spew.Printf("got %v, want %v", result, expected))
 	}
 }
+
+func TestExtractFlagValueForBodyParamInvalidJSON(t *testing.T) {
+	command := &cobra.Command{}
+	multipleFlags := NewMultipleFlags(command, map[string]schema.FlagParameterOption{
+		"jsonParam": {FlagName: "jsonParam", Type: "json"},
+	})
+	multipleFlags.result = map[string]interface{}{
+		"jsonParam": func() *string { s := "not-json"; return &s }(),
+	}
+	command.Flags().Lookup("jsonParam").Changed = true
+
+	_, err := multipleFlags.ExtractFlagValueForBodyParam()
+	if err == nil {
+		t.Error("expected an error for invalid JSON, got nil")
+	}
+}

cmd/run.go

@@ -62,13 +62,15 @@ func initRun(runs schema.RunCatalog) {
 			Run: func(cmd *cobra.Command, args []string) {
 				pathValues := make([]string, len(pathFlagValues))
 				queryParams := multipleFlagsForQuery.ExtractFlagValueForQueryParam()
-				body := multipleFlagsForBody.ExtractFlagValueForBodyParam()
+				body, err := multipleFlagsForBody.ExtractFlagValueForBodyParam()
+				if err != nil {
+					fmt.Fprintf(os.Stderr, "%s\n", err)
+					return
+				}
 				for i, v := range pathFlagValues {
 					pathValues[i] = *v
 				}
 
-				var err error
-
 				if len(bodyFlags) == 0 {
 					body = nil
 				}