[WIP] Working draft version of validator and a couple of validation rules

README.md

@@ -24,8 +24,8 @@ import (
 
 func main() {
 	// Schema
-	fields := graphql.FieldConfigMap{
-		"hello": &graphql.FieldConfig{
+	fields := graphql.Fields{
+		"hello": &graphql.Field{
 			Type: graphql.String,
 			Resolve: func(p graphql.GQLFRParams) interface{} {
 				return "world"

abstract_test.go

@@ -11,17 +11,17 @@ import (
 )
 
 type testDog struct {
-	Name  string
-	Woofs bool
+	Name  string `json:"name"`
+	Woofs bool   `json:"woofs"`
 }
 
 type testCat struct {
-	Name  string
-	Meows bool
+	Name  string `json:"name"`
+	Meows bool   `json:"meows"`
 }
 
 type testHuman struct {
-	Name string
+	Name string `json:"name"`
 }
 
 func TestIsTypeOfUsedToResolveRuntimeTypeForInterface(t *testing.T) {
@@ -168,21 +168,9 @@ func TestIsTypeOfUsedToResolveRuntimeTypeForUnion(t *testing.T) {
 		Fields: graphql.Fields{
 			"name": &graphql.Field{
 				Type: graphql.String,
-				Resolve: func(p graphql.ResolveParams) interface{} {
-					if dog, ok := p.Source.(*testDog); ok {
-						return dog.Name
-					}
-					return nil
-				},
 			},
 			"woofs": &graphql.Field{
 				Type: graphql.Boolean,
-				Resolve: func(p graphql.ResolveParams) interface{} {
-					if dog, ok := p.Source.(*testDog); ok {
-						return dog.Woofs
-					}
-					return nil
-				},
 			},
 		},
 	})
@@ -195,21 +183,9 @@ func TestIsTypeOfUsedToResolveRuntimeTypeForUnion(t *testing.T) {
 		Fields: graphql.Fields{
 			"name": &graphql.Field{
 				Type: graphql.String,
-				Resolve: func(p graphql.ResolveParams) interface{} {
-					if cat, ok := p.Source.(*testCat); ok {
-						return cat.Name
-					}
-					return nil
-				},
 			},
 			"meows": &graphql.Field{
 				Type: graphql.Boolean,
-				Resolve: func(p graphql.ResolveParams) interface{} {
-					if cat, ok := p.Source.(*testCat); ok {
-						return cat.Meows
-					}
-					return nil
-				},
 			},
 		},
 	})
@@ -219,15 +195,6 @@ func TestIsTypeOfUsedToResolveRuntimeTypeForUnion(t *testing.T) {
 		Types: []*graphql.Object{
 			dogType, catType,
 		},
-		ResolveType: func(value interface{}, info graphql.ResolveInfo) *graphql.Object {
-			if _, ok := value.(*testCat); ok {
-				return catType
-			}
-			if _, ok := value.(*testDog); ok {
-				return dogType
-			}
-			return nil
-		},
 	})
 	schema, err := graphql.NewSchema(graphql.SchemaConfig{
 		Query: graphql.NewObject(graphql.ObjectConfig{
@@ -251,11 +218,12 @@ func TestIsTypeOfUsedToResolveRuntimeTypeForUnion(t *testing.T) {
 
 	query := `{
       pets {
-        name
         ... on Dog {
+          name
           woofs
         }
         ... on Cat {
+          name
           meows
         }
       }
@@ -281,7 +249,6 @@ func TestIsTypeOfUsedToResolveRuntimeTypeForUnion(t *testing.T) {
 		Schema:        schema,
 		RequestString: query,
 	})
-
 	if len(result.Errors) != 0 {
 		t.Fatalf("wrong result, unexpected errors: %v", result.Errors)
 	}
@@ -464,66 +431,28 @@ func TestResolveTypeOnUnionYieldsUsefulError(t *testing.T) {
 		Fields: graphql.Fields{
 			"name": &graphql.Field{
 				Type: graphql.String,
-				Resolve: func(p graphql.ResolveParams) interface{} {
-					if human, ok := p.Source.(*testHuman); ok {
-						return human.Name
-					}
-					return nil
-				},
 			},
 		},
 	})
 	dogType := graphql.NewObject(graphql.ObjectConfig{
 		Name: "Dog",
-		IsTypeOf: func(value interface{}, info graphql.ResolveInfo) bool {
-			_, ok := value.(*testDog)
-			return ok
-		},
 		Fields: graphql.Fields{
 			"name": &graphql.Field{
 				Type: graphql.String,
-				Resolve: func(p graphql.ResolveParams) interface{} {
-					if dog, ok := p.Source.(*testDog); ok {
-						return dog.Name
-					}
-					return nil
-				},
 			},
 			"woofs": &graphql.Field{
 				Type: graphql.Boolean,
-				Resolve: func(p graphql.ResolveParams) interface{} {
-					if dog, ok := p.Source.(*testDog); ok {
-						return dog.Woofs
-					}
-					return nil
-				},
 			},
 		},
 	})
 	catType := graphql.NewObject(graphql.ObjectConfig{
 		Name: "Cat",
-		IsTypeOf: func(value interface{}, info graphql.ResolveInfo) bool {
-			_, ok := value.(*testCat)
-			return ok
-		},
 		Fields: graphql.Fields{
 			"name": &graphql.Field{
 				Type: graphql.String,
-				Resolve: func(p graphql.ResolveParams) interface{} {
-					if cat, ok := p.Source.(*testCat); ok {
-						return cat.Name
-					}
-					return nil
-				},
 			},
 			"meows": &graphql.Field{
 				Type: graphql.Boolean,
-				Resolve: func(p graphql.ResolveParams) interface{} {
-					if cat, ok := p.Source.(*testCat); ok {
-						return cat.Meows
-					}
-					return nil
-				},
 			},
 		},
 	})
@@ -568,11 +497,12 @@ func TestResolveTypeOnUnionYieldsUsefulError(t *testing.T) {
 
 	query := `{
       pets {
-        name
         ... on Dog {
+          name
           woofs
         }
         ... on Cat {
+          name
           meows
         }
       }

definition.go

@@ -42,34 +42,45 @@ var _ Input = (*List)(nil)
 var _ Input = (*NonNull)(nil)
 
 func IsInputType(ttype Type) bool {
-	Named := GetNamed(ttype)
-	if _, ok := Named.(*Scalar); ok {
+	named := GetNamed(ttype)
+	if _, ok := named.(*Scalar); ok {
 		return true
 	}
-	if _, ok := Named.(*Enum); ok {
+	if _, ok := named.(*Enum); ok {
 		return true
 	}
-	if _, ok := Named.(*InputObject); ok {
+	if _, ok := named.(*InputObject); ok {
 		return true
 	}
 	return false
 }
 
 func IsOutputType(ttype Type) bool {
-	Named := GetNamed(ttype)
-	if _, ok := Named.(*Scalar); ok {
+	name := GetNamed(ttype)
+	if _, ok := name.(*Scalar); ok {
 		return true
 	}
-	if _, ok := Named.(*Object); ok {
+	if _, ok := name.(*Object); ok {
 		return true
 	}
-	if _, ok := Named.(*Interface); ok {
+	if _, ok := name.(*Interface); ok {
 		return true
 	}
-	if _, ok := Named.(*Union); ok {
+	if _, ok := name.(*Union); ok {
 		return true
 	}
-	if _, ok := Named.(*Enum); ok {
+	if _, ok := name.(*Enum); ok {
+		return true
+	}
+	return false
+}
+
+func IsLeafType(ttype Type) bool {
+	named := GetNamed(ttype)
+	if _, ok := named.(*Scalar); ok {
+		return true
+	}
+	if _, ok := named.(*Enum); ok {
 		return true
 	}
 	return false
@@ -100,6 +111,19 @@ var _ Composite = (*Object)(nil)
 var _ Composite = (*Interface)(nil)
 var _ Composite = (*Union)(nil)
 
+func IsCompositeType(ttype interface{}) bool {
+	if _, ok := ttype.(*Object); ok {
+		return true
+	}
+	if _, ok := ttype.(*Interface); ok {
+		return true
+	}
+	if _, ok := ttype.(*Union); ok {
+		return true
+	}
+	return false
+}
+
 // These types may describe the parent context of a selection set.
 type Abstract interface {
 	ObjectType(value interface{}, info ResolveInfo) *Object
@@ -110,6 +134,24 @@ type Abstract interface {
 var _ Abstract = (*Interface)(nil)
 var _ Abstract = (*Union)(nil)
 
+type Nullable interface {
+}
+
+var _ Nullable = (*Scalar)(nil)
+var _ Nullable = (*Object)(nil)
+var _ Nullable = (*Interface)(nil)
+var _ Nullable = (*Union)(nil)
+var _ Nullable = (*Enum)(nil)
+var _ Nullable = (*InputObject)(nil)
+var _ Nullable = (*List)(nil)
+
+func GetNullable(ttype Type) Nullable {
+	if ttype, ok := ttype.(*NonNull); ok {
+		return ttype.OfType
+	}
+	return ttype
+}
+
 // These named types do not include modifiers like List or NonNull.
 type Named interface {
 	String() string

examples/http/main.go

@@ -19,7 +19,7 @@ var data map[string]user
 /*
    Create User object type with fields "id" and "name" by using GraphQLObjectTypeConfig:
        - Name: name of object type
-       - Fields: a map of fields by using GraphQLFieldConfigMap
+       - Fields: a map of fields by using GraphQLFields
    Setup type of field use GraphQLFieldConfig
 */
 var userType = graphql.NewObject(
@@ -39,7 +39,7 @@ var userType = graphql.NewObject(
 /*
    Create Query object type with fields "user" has type [userType] by using GraphQLObjectTypeConfig:
        - Name: name of object type
-       - Fields: a map of fields by using GraphQLFieldConfigMap
+       - Fields: a map of fields by using GraphQLFields
    Setup type of field use GraphQLFieldConfig to define:
        - Type: type of field
        - Args: arguments to query with current field

graphql.go

@@ -25,7 +25,7 @@ func Do(p Params) *Result {
 			Errors: gqlerrors.FormatErrors(err),
 		}
 	}
-	validationResult := ValidateDocument(p.Schema, AST)
+	validationResult := ValidateDocument(&p.Schema, AST, nil)
 
 	if !validationResult.IsValid {
 		return &Result{

language/kinds/kinds.go

@@ -9,8 +9,8 @@ const (
 	Directive               = "Directive"
 	VariableDefinition      = "VariableDefinition"
 	Variable                = "Variable"
-	Named                   = "Named"
-	List                    = "List"
+	Named                   = "Named" // previously NamedType
+	List                    = "List"  // previously ListType
 	NonNull                 = "NonNull"
 	InlineFragment          = "InlineFragment"
 	FragmentSpread          = "FragmentSpread"