diff key must be scalar

CHANGELOG.md

@@ -4,6 +4,10 @@
 
 ### Changed
 
+#### `graphql`
+
+- Object key must now be scalar. ([#190](https://github.com/samsarahq/thunder/pull/190))
+
 #### `livesql`
 
 - Support filter types that serialize into `[]byte`. ([#172](https://github.com/samsarahq/thunder/pull/172))

graphql/schemabuilder/reflect.go

@@ -839,6 +839,16 @@ func (sb *schemaBuilder) buildStruct(typ reflect.Type) error {
 		}
 	}
 
+	isScalarType := func(typ graphql.Type) bool {
+		if nonNull, ok := typ.(*graphql.NonNull); ok {
+			typ = nonNull.Type
+		}
+		if _, ok := typ.(*graphql.Scalar); !ok {
+			return false
+		}
+		return true
+	}
+
 	object := &graphql.Object{
 		Name:        name,
 		Description: description,
@@ -888,6 +898,9 @@ func (sb *schemaBuilder) buildStruct(typ reflect.Type) error {
 			if object.Key != nil {
 				return fmt.Errorf("bad type %s: multiple key fields", typ)
 			}
+			if !isScalarType(built.Type) {
+				return fmt.Errorf("bad type %s: key type must be scalar, got %T", typ, built.Type)
+			}
 			object.Key = built.Resolve
 		}
 	}
@@ -921,6 +934,10 @@ func (sb *schemaBuilder) buildStruct(typ reflect.Type) error {
 		if !ok {
 			return fmt.Errorf("key field doesn't exist on object")
 		}
+
+		if !isScalarType(keyPtr.Type) {
+			return fmt.Errorf("bad type %s: key type must be scalar, got %s", typ, keyPtr.Type.String())
+		}
 		object.Key = keyPtr.Resolve
 	}
 

graphql/schemabuilder/reflect_test.go

@@ -370,13 +370,13 @@ type kitchenSinkArgs struct {
 	Hello               int64
 	Hello32             int32
 	Hello16             int16
-	HelloFloat32		float32
-	HelloFloat64		float64
+	HelloFloat32        float32
+	HelloFloat64        float64
 	FooBar              string
 	Bool                bool
 	OptionalInt         *int64
-	OptionalFloat32		*float32
-	OptionalFloat64		*float64
+	OptionalFloat32     *float32
+	OptionalFloat64     *float64
 	OptionalStruct      *inner
 	Ints                []int64
 	OptionalStructs     *[]*inner
@@ -448,8 +448,8 @@ func TestArgParser(t *testing.T) {
 		Hello:           20,
 		Hello32:         20,
 		Hello16:         20,
-		HelloFloat32:	 42.0,
-		HelloFloat64:	 42.0,
+		HelloFloat32:    42.0,
+		HelloFloat64:    42.0,
 		FooBar:          "foo!",
 		Bool:            true,
 		OptionalInt:     nil,
@@ -500,8 +500,8 @@ func TestArgParser(t *testing.T) {
 		Hello:               40,
 		Hello32:             40,
 		Hello16:             40,
-		HelloFloat64:		 40.0,
-		HelloFloat32:		 40.0,
+		HelloFloat64:        40.0,
+		HelloFloat32:        40.0,
 		FooBar:              "bar!",
 		Bool:                false,
 		OptionalInt:         &ten,
@@ -603,3 +603,74 @@ func TestBadArguments(t *testing.T) {
 		t.Errorf("expected non-struct args argument to fail, but received %s", err.Error())
 	}
 }
+
+func TestObjectKeyMustBeScalar(t *testing.T) {
+	t.Run("struct key tag", func(t *testing.T) {
+		type key struct{ Name string }
+		type object struct {
+			Key key `graphql:",key"`
+		}
+		builder := NewSchema()
+		builder.Object("object", object{})
+		builder.Query().FieldFunc("objects", func(ctx context.Context) []*object { return []*object(nil) })
+		_, err := builder.Build()
+		assert.Error(t, err, "key type must be scalar")
+	})
+
+	t.Run("string key tag", func(t *testing.T) {
+		type object struct {
+			Key string `graphql:",key"`
+		}
+		builder := NewSchema()
+		builder.Object("object", object{})
+		builder.Query().FieldFunc("objects", func(ctx context.Context) []*object { return []*object(nil) })
+		_, err := builder.Build()
+		assert.NoError(t, err)
+	})
+
+	t.Run("pointer string key tag", func(t *testing.T) {
+		type object struct {
+			Key *string `graphql:",key"`
+		}
+		builder := NewSchema()
+		builder.Object("object", object{})
+		builder.Query().FieldFunc("objects", func(ctx context.Context) []*object { return []*object(nil) })
+		_, err := builder.Build()
+		assert.NoError(t, err)
+	})
+
+	t.Run("struct key", func(t *testing.T) {
+		type key struct{ Name string }
+		type object struct {
+			Key key
+		}
+		builder := NewSchema()
+		builder.Object("object", object{}).Key("key")
+		builder.Query().FieldFunc("objects", func(ctx context.Context) []*object { return []*object(nil) })
+		_, err := builder.Build()
+		assert.Error(t, err, "key type must be scalar")
+	})
+
+	t.Run("string key", func(t *testing.T) {
+		type object struct {
+			Key string
+		}
+		builder := NewSchema()
+		builder.Object("object", object{}).Key("key")
+		builder.Query().FieldFunc("objects", func(ctx context.Context) []*object { return []*object(nil) })
+		_, err := builder.Build()
+		assert.NoError(t, err)
+	})
+
+	t.Run("pointer string key", func(t *testing.T) {
+		type object struct {
+			Key *string
+		}
+		builder := NewSchema()
+		builder.Object("object", object{}).Key("key")
+		builder.Query().FieldFunc("objects", func(ctx context.Context) []*object { return []*object(nil) })
+		_, err := builder.Build()
+		assert.NoError(t, err)
+	})
+
+}