clientgenv2/source_generator.go

@@ -145,13 +145,13 @@ func mergeFieldsRecursively(targetFields, sourceFields ResponseFieldList, preMer
 			})
 
 			targetField.ResponseFields, newPreMerged, newPostMerged = mergeFieldsRecursively(targetField.ResponseFields, sourceField.ResponseFields, newPreMerged, newPostMerged)
+
 			newPostMerged = append(newPostMerged, &StructSource{
 				Name: targetField.FieldTypeString(),
 				Type: targetField.ResponseFields.StructType(),
 			})
 		} else {
 			targetFieldsMap[sourceField.Name] = sourceField
-			responseFieldList = append(responseFieldList, sourceField)
 		}
 	}
 	for _, field := range targetFieldsMap {

clientgenv2/source_generator_test.go

@@ -0,0 +1,237 @@
+package clientgenv2
+
+import (
+	"go/types"
+	"testing"
+)
+
+func createTestStruct(fields []*types.Var, tags []string) *types.Struct {
+	return types.NewStruct(fields, tags)
+}
+
+func TestMergeFieldsRecursively(t *testing.T) {
+	tests := []struct {
+		name               string
+		targetFields       ResponseFieldList
+		sourceFields       ResponseFieldList
+		preMerged          []*StructSource
+		postMerged         []*StructSource
+		expectedFields     ResponseFieldList
+		expectedPreMerged  []*StructSource
+		expectedPostMerged []*StructSource
+	}{
+		{
+			name: "Basic merge case",
+			targetFields: ResponseFieldList{
+				{
+					Name: "field1",
+					Type: types.Typ[types.String],
+					Tags: []string{`json:"field1"`},
+				},
+			},
+			sourceFields: ResponseFieldList{
+				{
+					Name: "field2",
+					Type: types.Typ[types.Int],
+					Tags: []string{`json:"field2"`},
+				},
+			},
+			preMerged:  []*StructSource{},
+			postMerged: []*StructSource{},
+			expectedFields: ResponseFieldList{
+				{
+					Name: "field1",
+					Type: types.Typ[types.String],
+					Tags: []string{`json:"field1"`},
+				},
+				{
+					Name: "field2",
+					Type: types.Typ[types.Int],
+					Tags: []string{`json:"field2"`},
+				},
+			},
+			expectedPreMerged:  []*StructSource{},
+			expectedPostMerged: []*StructSource{},
+		},
+		{
+			name: "Merge case with complex query including fragments",
+			targetFields: ResponseFieldList{
+				{
+					Name: "id",
+					Type: types.Typ[types.String],
+					Tags: []string{`json:"id"`},
+				},
+				{
+					Name: "profile",
+					Type: types.NewPointer(types.NewNamed(
+						types.NewTypeName(0, nil, "A_User_Profile", nil),
+						createTestStruct([]*types.Var{
+							types.NewVar(0, nil, "id", types.Typ[types.String]),
+							types.NewVar(0, nil, "name", types.Typ[types.String]),
+						}, []string{`json:"id"`, `json:"name"`}),
+						nil,
+					)),
+					Tags: []string{`json:"profile"`},
+					ResponseFields: ResponseFieldList{
+						{
+							Name: "id",
+							Type: types.Typ[types.String],
+							Tags: []string{`json:"id"`},
+						},
+						{
+							Name: "ProfileFragment",
+							Type: types.NewPointer(types.NewNamed(
+								types.NewTypeName(0, nil, "ProfileFragment", nil),
+								createTestStruct([]*types.Var{
+									types.NewVar(0, nil, "name", types.Typ[types.String]),
+								}, []string{`json:"name"`}),
+								nil,
+							)),
+							Tags:             []string{`json:"ProfileFragment"`},
+							IsFragmentSpread: true,
+							ResponseFields: ResponseFieldList{
+								{
+									Name: "name",
+									Type: types.Typ[types.String],
+									Tags: []string{`json:"name"`},
+								},
+							},
+						},
+					},
+				},
+			},
+			sourceFields: ResponseFieldList{
+				{
+					Name: "profile",
+					Type: types.NewPointer(types.NewNamed(
+						types.NewTypeName(0, nil, "Profile", nil),
+						createTestStruct([]*types.Var{
+							types.NewVar(0, nil, "id", types.Typ[types.String]),
+							types.NewVar(0, nil, "name", types.Typ[types.String]),
+						}, []string{`json:"id"`, `json:"name"`}),
+						nil,
+					)),
+					Tags: []string{`json:"profile"`},
+					ResponseFields: ResponseFieldList{
+						{
+							Name: "name",
+							Type: types.Typ[types.String],
+							Tags: []string{`json:"name"`},
+						},
+					},
+				},
+			},
+			preMerged:  []*StructSource{},
+			postMerged: []*StructSource{},
+			expectedFields: ResponseFieldList{
+				{
+					Name: "id",
+					Type: types.Typ[types.String],
+					Tags: []string{`json:"id"`},
+				},
+				{
+					Name: "profile",
+					Type: types.NewPointer(types.NewNamed(
+						types.NewTypeName(0, nil, "A_User_Profile", nil),
+						createTestStruct([]*types.Var{
+							types.NewVar(0, nil, "id", types.Typ[types.String]),
+							types.NewVar(0, nil, "name", types.Typ[types.String]),
+						}, []string{`json:"id"`, `json:"name"`}),
+						nil,
+					)),
+					Tags: []string{`json:"profile"`},
+					ResponseFields: ResponseFieldList{
+						{
+							Name: "id",
+							Type: types.Typ[types.String],
+							Tags: []string{`json:"id"`},
+						},
+						{
+							Name: "ProfileFragment",
+							Type: types.NewPointer(types.NewNamed(
+								types.NewTypeName(0, nil, "ProfileFragment", nil),
+								createTestStruct([]*types.Var{
+									types.NewVar(0, nil, "name", types.Typ[types.String]),
+								}, []string{`json:"name"`}),
+								nil,
+							)),
+							Tags:             []string{`json:"ProfileFragment"`},
+							IsFragmentSpread: true,
+							ResponseFields: ResponseFieldList{
+								{
+									Name: "name",
+									Type: types.Typ[types.String],
+									Tags: []string{`json:"name"`},
+								},
+							},
+						},
+					},
+				},
+			},
+			expectedPreMerged: []*StructSource{
+				{
+					Name: "Nested",
+					Type: createTestStruct([]*types.Var{
+						types.NewVar(0, nil, "id", types.Typ[types.String]),
+					}, []string{`json:"id"`}),
+				},
+				{
+					Name: "Nested",
+					Type: createTestStruct([]*types.Var{
+						types.NewVar(0, nil, "name", types.Typ[types.String]),
+					}, []string{`json:"name"`}),
+				},
+			},
+			expectedPostMerged: []*StructSource{
+				{
+					Name: "Nested",
+					Type: createTestStruct([]*types.Var{
+						types.NewVar(0, nil, "id", types.Typ[types.String]),
+						types.NewVar(0, nil, "name", types.Typ[types.String]),
+					}, []string{`json:"id"`, `json:"name"`}),
+				},
+			},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			resultFields, resultPreMerged, resultPostMerged := mergeFieldsRecursively(
+				tt.targetFields,
+				tt.sourceFields,
+				tt.preMerged,
+				tt.postMerged,
+			)
+
+			if len(tt.expectedFields) != len(resultFields) {
+				t.Errorf("Number of fields does not match: got %v, want %v", len(resultFields), len(tt.expectedFields))
+				return
+			}
+
+			if len(tt.expectedPreMerged) != len(resultPreMerged) {
+				t.Errorf("Number of preMerged does not match: got %v, want %v", len(resultPreMerged), len(tt.expectedPreMerged))
+			}
+
+			if len(tt.expectedPostMerged) != len(resultPostMerged) {
+				t.Errorf("Number of postMerged does not match: got %v, want %v", len(resultPostMerged), len(tt.expectedPostMerged))
+			}
+
+			for i := range tt.expectedFields {
+				if tt.expectedFields[i].Name != resultFields[i].Name {
+					t.Errorf("Field name does not match: got %v, want %v", resultFields[i].Name, tt.expectedFields[i].Name)
+				}
+				if tt.expectedFields[i].Type.String() != resultFields[i].Type.String() {
+					t.Errorf("Field type does not match: got %v, want %v", resultFields[i].Type.String(), tt.expectedFields[i].Type.String())
+				}
+				if len(tt.expectedFields[i].Tags) != len(resultFields[i].Tags) {
+					t.Errorf("Number of tags does not match: got %v, want %v", len(resultFields[i].Tags), len(tt.expectedFields[i].Tags))
+				}
+				for j, tag := range tt.expectedFields[i].Tags {
+					if tag != resultFields[i].Tags[j] {
+						t.Errorf("Tag does not match: got %v, want %v", resultFields[i].Tags[j], tag)
+					}
+				}
+			}
+		})
+	}
+}

clientv2/client.go

@@ -543,6 +543,7 @@ func (e *Encoder) Encode(v reflect.Value) ([]byte, error) {
 	}
 
 	t := v.Type()
+
 	switch t.Kind() {
 	case reflect.Ptr:
 		return e.encodePtr(v)
@@ -676,18 +677,6 @@ func (e *Encoder) encodeStruct(v reflect.Value) ([]byte, error) {
 			continue
 		}
 
-		// omitemptyが無効な場合、nilスライスは空のスライス[]として扱う
-		if !e.EnableInputJsonOmitemptyTag && fieldValue.Kind() == reflect.Slice && fieldValue.IsNil() {
-			result[field.jsonName] = []byte("[]")
-			continue
-		}
-
-		// omitemptyが無効な場合、nilポインタはnullとして扱い、出力に含める
-		if !e.EnableInputJsonOmitemptyTag && fieldValue.Kind() == reflect.Ptr && fieldValue.IsNil() {
-			result[field.jsonName] = []byte("null")
-			continue
-		}
-
 		encodedValue, err := e.Encode(fieldValue)
 		if err != nil {
 			return nil, err
@@ -699,6 +688,10 @@ func (e *Encoder) encodeStruct(v reflect.Value) ([]byte, error) {
 
 // encodeMap encodes a map value
 func (e *Encoder) encodeMap(v reflect.Value) ([]byte, error) {
+	if v.IsNil() {
+		return []byte("null"), nil
+	}
+
 	result := make(map[string]json.RawMessage)
 	for _, key := range v.MapKeys() {
 		encodedKey, err := e.Encode(key)
@@ -720,6 +713,10 @@ func (e *Encoder) encodeMap(v reflect.Value) ([]byte, error) {
 
 // encodeSlice encodes a slice value
 func (e *Encoder) encodeSlice(v reflect.Value) ([]byte, error) {
+	if v.IsNil() {
+		return []byte("null"), nil
+	}
+
 	result := make([]json.RawMessage, v.Len())
 	for i := range v.Len() {
 		encodedValue, err := e.Encode(v.Index(i))

clientv2/client_test.go

@@ -976,6 +976,7 @@ func TestEncoder_encodeStruct(t *testing.T) {
 		Nickname  string   `json:"nickname,omitempty"`
 		Empty     string   `json:"-"`
 		unexposed string
+		Hobbies   []string `json:"hobbies"`
 	}
 
 	zip := "123-4567"
@@ -997,6 +998,7 @@ func TestEncoder_encodeStruct(t *testing.T) {
 				Address:  Address{City: "Tokyo", Country: "Japan", Zip: &zip},
 				Tags:     []string{"tag1", "tag2"},
 				Nickname: "Johnny",
+				Hobbies:  []string{"reading", "swimming"},
 			},
 			enableOmitemptyTag: true,
 			want: map[string]any{
@@ -1007,6 +1009,7 @@ func TestEncoder_encodeStruct(t *testing.T) {
 				"address":  map[string]any{"city": "Tokyo", "country": "Japan", "zip": "123-4567"},
 				"tags":     []any{"tag1", "tag2"},
 				"nickname": "Johnny",
+				"hobbies":  []any{"reading", "swimming"},
 			},
 		},
 		{
@@ -1020,6 +1023,7 @@ func TestEncoder_encodeStruct(t *testing.T) {
 				"name":    "John",
 				"email2":  nil,
 				"address": map[string]any{"city": "Tokyo"},
+				"hobbies": nil,
 			},
 		},
 		{
@@ -1035,8 +1039,62 @@ func TestEncoder_encodeStruct(t *testing.T) {
 				"email":    nil,
 				"email2":   nil,
 				"address":  map[string]any{"city": "Tokyo", "country": "", "zip": nil},
-				"tags":     []any{},
+				"tags":     nil,
 				"nickname": "",
+				"hobbies":  nil,
+			},
+		},
+		{
+			name: "nil slice set to null on omitempty disabled",
+			input: Person{
+				Name:    "John",
+				Address: Address{City: "Tokyo"},
+			},
+			enableOmitemptyTag: false,
+			want: map[string]any{
+				"name":    "John",
+				"age":     int64(0),
+				"email":   nil, // omitempty is ignored
+				"email2":  nil,
+				"tags":    nil, // omitempty is ignored
+				"hobbies": nil,
+				"address": map[string]any{
+					"city":    "Tokyo",
+					"country": "", // omitempty is ignored
+					"zip":     nil,
+				},
+				"nickname": "", // omitempty is ignored
+			},
+		},
+		{
+			name: "zero value of slice (i.e. nil slice) dropped on omitempty enabled",
+			input: Person{
+				Name:    "John",
+				Address: Address{City: "Tokyo"},
+				Hobbies: nil,
+				Tags:    nil, // will be dropped as omitempty is enabled
+			},
+			enableOmitemptyTag: true,
+			want: map[string]any{
+				"name":    "John",
+				"email2":  nil,
+				"hobbies": nil,
+				"address": map[string]any{"city": "Tokyo"},
+			},
+		},
+		{
+			name: "nil slice set to null",
+			input: Person{
+				Tags:    []string{}, // this is not zero value, so omitempty will not be applied
+				Hobbies: nil,        // will continue to be nil
+			},
+			enableOmitemptyTag: true,
+			want: map[string]any{
+				"name":    "",
+				"email2":  nil,
+				"tags":    []any{},
+				"hobbies": nil,
+				"address": map[string]any{"city": ""},
 			},
 		},
 	}