fix: preserve string-typed params as raw strings instead of parsing as JSON

Author: yuguo.dtpe

cmd/cmd_action.go

@@ -4,6 +4,7 @@ import (
 	"encoding/json"
 	"fmt"
 	"sort"
+	"strconv"
 	"strings"
 
 	"github.com/spf13/cobra"
@@ -87,6 +88,7 @@ func doAction(ctx *Context, serviceName, action string) (err error) {
 	method := "GET"
 	contentType := ""
 	apiInfo := rootSupport.GetApiInfo(serviceName, action)
+	apiMeta := rootSupport.GetApiMeta(serviceName, action)
 
 	if apiInfo != nil && apiInfo.Method != "" {
 		method = apiInfo.Method
@@ -100,7 +102,14 @@ func doAction(ctx *Context, serviceName, action string) (err error) {
 	for _, f := range ctx.dynamicFlags.flags {
 		// rebuild input
 		if f.Name != "body" {
-			if a, success := util.ParseToJsonArrayOrObject(strings.TrimSpace(f.value)); success {
+			// Skip JSON parsing for parameters whose declared type is "string".
+			// Without this, a value like '{"Statement":[...]}' is deserialized
+			// into a Go map and then flattened into query params, which breaks
+			// APIs that expect a raw JSON string (e.g. IAM CreatePolicy's
+			// PolicyDocument parameter).
+			if isStringParam(apiMeta, f.Name) {
+				input[f.Name] = f.value
+			} else if a, success := util.ParseToJsonArrayOrObject(strings.TrimSpace(f.value)); success {
 				input[f.Name] = a
 			} else {
 				input[f.Name] = f.value
@@ -173,6 +182,69 @@ func doAction(ctx *Context, serviceName, action string) (err error) {
 	return
 }
 
+// isStringParam reports whether the named parameter should be treated as a
+// literal string when rebuilding request input.
+//
+// This includes both parameters declared as type "string" and indexed
+// elements of repeated string arrays whose metadata key ends with ".N" and is
+// declared as "array[string]" (for example ResourceNames.N -> --ResourceNames.0).
+// In those cases the caller must NOT attempt to parse the value as JSON.
+func isStringParam(apiMeta *ApiMeta, name string) bool {
+	mt, matchedKey, ok := getRequestMetaType(apiMeta, name)
+	if !ok {
+		return false
+	}
+
+	switch mt.TypeName {
+	case "string":
+		return true
+	case "array[string]":
+		return isIndexedStringArrayElement(matchedKey)
+	default:
+		return false
+	}
+}
+
+func isIndexedStringArrayElement(matchedKey string) bool {
+	return strings.HasSuffix(matchedKey, ".N")
+}
+
+func getRequestMetaType(apiMeta *ApiMeta, name string) (*MetaType, string, bool) {
+	if apiMeta == nil || apiMeta.Request == nil || apiMeta.Request.MetaTypes == nil {
+		return nil, "", false
+	}
+
+	if mt, ok := apiMeta.Request.MetaTypes[name]; ok {
+		return mt, name, true
+	}
+
+	normalizedName := normalizeMetaTypeKey(name)
+	if normalizedName == name {
+		return nil, "", false
+	}
+
+	mt, ok := apiMeta.Request.MetaTypes[normalizedName]
+	return mt, normalizedName, ok
+}
+
+func normalizeMetaTypeKey(name string) string {
+	parts := strings.Split(name, ".")
+	changed := false
+
+	for i, part := range parts {
+		if _, err := strconv.Atoi(part); err == nil {
+			parts[i] = "N"
+			changed = true
+		}
+	}
+
+	if !changed {
+		return name
+	}
+
+	return strings.Join(parts, ".")
+}
+
 func actionUsageTemplate(params []string) string {
 	sort.Strings(params)
 

cmd/cmd_action_test.go

@@ -0,0 +1,125 @@
+package cmd
+
+import "testing"
+
+func TestIsStringParam(t *testing.T) {
+	tests := []struct {
+		name     string
+		apiMeta  *ApiMeta
+		param    string
+		expected bool
+	}{
+		{
+			name:     "nil apiMeta",
+			apiMeta:  nil,
+			param:    "PolicyDocument",
+			expected: false,
+		},
+		{
+			name: "string type param",
+			apiMeta: &ApiMeta{
+				Request: &Meta{
+					MetaTypes: map[string]*MetaType{
+						"PolicyDocument": {TypeName: "string"},
+						"PolicyName":     {TypeName: "string"},
+					},
+				},
+			},
+			param:    "PolicyDocument",
+			expected: true,
+		},
+		{
+			name: "non-string type param",
+			apiMeta: &ApiMeta{
+				Request: &Meta{
+					MetaTypes: map[string]*MetaType{
+						"Filters": {TypeName: "object"},
+					},
+				},
+			},
+			param:    "Filters",
+			expected: false,
+		},
+		{
+			name: "unknown param",
+			apiMeta: &ApiMeta{
+				Request: &Meta{
+					MetaTypes: map[string]*MetaType{
+						"PolicyName": {TypeName: "string"},
+					},
+				},
+			},
+			param:    "Unknown",
+			expected: false,
+		},
+		{
+			name: "indexed repeated string param",
+			apiMeta: &ApiMeta{
+				Request: &Meta{
+					MetaTypes: map[string]*MetaType{
+						"TagFilters.N.Key": {TypeName: "string"},
+					},
+				},
+			},
+			param:    "TagFilters.1.Key",
+			expected: true,
+		},
+		{
+			name: "indexed repeated string array element",
+			apiMeta: &ApiMeta{
+				Request: &Meta{
+					MetaTypes: map[string]*MetaType{
+						"TagFilters.N.Values.N": {TypeName: "array[string]"},
+					},
+				},
+			},
+			param:    "TagFilters.1.Values.1",
+			expected: true,
+		},
+		{
+			name: "indexed root string array element",
+			apiMeta: &ApiMeta{
+				Request: &Meta{
+					MetaTypes: map[string]*MetaType{
+						"ResourceNames.N": {TypeName: "array[string]"},
+					},
+				},
+			},
+			param:    "ResourceNames.0",
+			expected: true,
+		},
+		{
+			name: "root string array is not treated as string literal",
+			apiMeta: &ApiMeta{
+				Request: &Meta{
+					MetaTypes: map[string]*MetaType{
+						"ResourceNames": {TypeName: "array[string]"},
+					},
+				},
+			},
+			param:    "ResourceNames",
+			expected: false,
+		},
+		{
+			name: "indexed repeated non-string param",
+			apiMeta: &ApiMeta{
+				Request: &Meta{
+					MetaTypes: map[string]*MetaType{
+						"TagFilters.N": {TypeName: "object"},
+					},
+				},
+			},
+			param:    "TagFilters.1",
+			expected: false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := isStringParam(tt.apiMeta, tt.param)
+			if got != tt.expected {
+				t.Errorf("isStringParam(%v, %q) = %v, want %v", tt.apiMeta, tt.param, got, tt.expected)
+			}
+		})
+	}
+}

cmd/root_support.go

@@ -117,6 +117,13 @@ func (r *RootSupport) GetVersion(svc string) string {
 	return r.Versions[svc]
 }
 
+func (r *RootSupport) GetApiMeta(svc string, action string) *ApiMeta {
+	if metas, ok := r.SupportTypes[svc]; ok {
+		return metas[action]
+	}
+	return nil
+}
+
 func (r *RootSupport) GetApiInfo(svc string, action string) *ApiInfo {
 	for k, v := range r.SupportAction {
 		if k == svc {