Support for embedded struct type in resolver

example/social/social.go

@@ -73,15 +73,19 @@ func (r *searchResult) ToUser() (*user, bool) {
 	return res, ok
 }
 
+type contact struct {
+	Email string
+	Phone string
+}
+
 type user struct {
 	IDField   string
 	NameField string
 	RoleField string
-	Email     string
-	Phone     string
 	Address   *[]string
 	Friends   *[]*user
 	CreatedAt graphql.Time
+	contact
 }
 
 func (u user) ID() graphql.ID {
@@ -126,37 +130,45 @@ var users = []*user{
 		IDField:   "0x01",
 		NameField: "Albus Dumbledore",
 		RoleField: "ADMIN",
-		Email:     "Albus@hogwarts.com",
-		Phone:     "000-000-0000",
 		Address:   &[]string{"Office @ Hogwarts", "where Horcruxes are"},
 		CreatedAt: graphql.Time{Time: time.Now()},
+		contact: contact{
+			Email: "Albus@hogwarts.com",
+			Phone: "000-000-0000",
+		},
 	},
 	{
 		IDField:   "0x02",
 		NameField: "Harry Potter",
 		RoleField: "USER",
-		Email:     "harry@hogwarts.com",
-		Phone:     "000-000-0001",
 		Address:   &[]string{"123 dorm room @ Hogwarts", "456 random place"},
 		CreatedAt: graphql.Time{Time: time.Now()},
+		contact: contact{
+			Email: "harry@hogwarts.com",
+			Phone: "000-000-0001",
+		},
 	},
 	{
 		IDField:   "0x03",
 		NameField: "Hermione Granger",
 		RoleField: "USER",
-		Email:     "hermione@hogwarts.com",
-		Phone:     "000-000-0011",
 		Address:   &[]string{"233 dorm room @ Hogwarts", "786 @ random place"},
 		CreatedAt: graphql.Time{Time: time.Now()},
+		contact: contact{
+			Email: "hermione@hogwarts.com",
+			Phone: "000-000-0011",
+		},
 	},
 	{
 		IDField:   "0x04",
 		NameField: "Ronald Weasley",
 		RoleField: "USER",
-		Email:     "ronald@hogwarts.com",
-		Phone:     "000-000-0111",
 		Address:   &[]string{"411 dorm room @ Hogwarts", "981 @ random place"},
 		CreatedAt: graphql.Time{Time: time.Now()},
+		contact: contact{
+			Email: "ronald@hogwarts.com",
+			Phone: "000-000-0111",
+		},
 	},
 }
 

internal/exec/exec.go

@@ -217,7 +217,7 @@ func execFieldSelection(ctx context.Context, r *Request, s *resolvable.Schema, f
 			if res.Kind() == reflect.Ptr {
 				res = res.Elem()
 			}
-			result = res.Field(f.field.FieldIndex)
+			result = res.FieldByIndex(f.field.FieldIndex)
 		}
 		return nil
 	}()

internal/exec/resolvable/resolvable.go

@@ -34,7 +34,7 @@ type Field struct {
 	schema.Field
 	TypeName    string
 	MethodIndex int
-	FieldIndex  int
+	FieldIndex  []int
 	HasContext  bool
 	HasError    bool
 	ArgsPacker  *packer.StructPacker
@@ -43,7 +43,7 @@ type Field struct {
 }
 
 func (f *Field) UseMethodResolver() bool {
-	return f.FieldIndex == -1
+	return len(f.FieldIndex) == 0
 }
 
 type TypeAssertion struct {
@@ -228,13 +228,17 @@ func (b *execBuilder) makeObjectExec(typeName string, fields schema.FieldList, p
 
 	Fields := make(map[string]*Field)
 	rt := unwrapPtr(resolverType)
+	fieldsCount := getFieldCount(rt, map[string]int{})
 	for _, f := range fields {
-		fieldIndex := -1
+		var fieldIndex []int
 		methodIndex := findMethod(resolverType, f.Name)
 		if b.schema.UseFieldResolvers && methodIndex == -1 {
-			fieldIndex = findField(rt, f.Name)
+			if fieldsCount[strings.ToLower(stripUnderscore(f.Name))] > 1 {
+				return nil, fmt.Errorf("%s does not resolve %q: ambiguous field %q", resolverType, typeName, f.Name)
+			}
+			fieldIndex = findField(rt, f.Name, []int{})
 		}
-		if methodIndex == -1 && fieldIndex == -1 {
+		if methodIndex == -1 && len(fieldIndex) == 0 {
 			hint := ""
 			if findMethod(reflect.PtrTo(resolverType), f.Name) != -1 {
 				hint = " (hint: the method exists on the pointer type)"
@@ -247,7 +251,7 @@ func (b *execBuilder) makeObjectExec(typeName string, fields schema.FieldList, p
 		if methodIndex != -1 {
 			m = resolverType.Method(methodIndex)
 		} else {
-			sf = rt.Field(fieldIndex)
+			sf = rt.FieldByIndex(fieldIndex)
 		}
 		fe, err := b.makeFieldExec(typeName, f, m, sf, methodIndex, fieldIndex, methodHasReceiver)
 		if err != nil {
@@ -290,7 +294,7 @@ var contextType = reflect.TypeOf((*context.Context)(nil)).Elem()
 var errorType = reflect.TypeOf((*error)(nil)).Elem()
 
 func (b *execBuilder) makeFieldExec(typeName string, f *schema.Field, m reflect.Method, sf reflect.StructField,
-	methodIndex, fieldIndex int, methodHasReceiver bool) (*Field, error) {
+	methodIndex int, fieldIndex []int, methodHasReceiver bool) (*Field, error) {
 
 	var argsPacker *packer.StructPacker
 	var hasError bool
@@ -380,13 +384,46 @@ func findMethod(t reflect.Type, name string) int {
 	return -1
 }
 
-func findField(t reflect.Type, name string) int {
+func findField(t reflect.Type, name string, index []int) []int {
 	for i := 0; i < t.NumField(); i++ {
-		if strings.EqualFold(stripUnderscore(name), stripUnderscore(t.Field(i).Name)) {
-			return i
+		field := t.Field(i)
+
+		if field.Type.Kind() == reflect.Struct && field.Anonymous {
+			newIndex := findField(field.Type, name, []int{i})
+			if len(newIndex) > 1 {
+				return append(index, newIndex...)
+			}
+		}
+
+		if strings.EqualFold(stripUnderscore(name), stripUnderscore(field.Name)) {
+			return append(index, i)
 		}
 	}
-	return -1
+
+	return index
+}
+
+// getFieldCount helps resolve ambiguity when more than one embedded struct contains fields with the same name.
+func getFieldCount(t reflect.Type, count map[string]int) map[string]int {
+	if t.Kind() != reflect.Struct {
+		return nil
+	}
+
+	for i := 0; i < t.NumField(); i++ {
+		field := t.Field(i)
+		fieldName := strings.ToLower(stripUnderscore(field.Name))
+
+		if field.Type.Kind() == reflect.Struct && field.Anonymous {
+			count = getFieldCount(field.Type, count)
+		} else {
+			if _, ok := count[fieldName]; !ok {
+				count[fieldName] = 0
+			}
+			count[fieldName]++
+		}
+	}
+
+	return count
 }
 
 func unwrapNonNull(t common.Type) (common.Type, bool) {