Add GraphQLSchema types field

This is a rebased and updated version of @tgriesser's #199. I further extended it to completely remove the side-effectful mutation of Interface types rather than just deferring that mutation to schema creation time.

This introduces a *breaking* change to the Type System API. Now, any individual Interface type does not have the required information to answer `getPossibleTypes` or `isPossibleType` without knowing the other types in the Schema. These methods were moved to the Schema API, accepting the abstract type as the first parameter.

This also introduces a *breaking* change to the type comparator functions: `isTypeSubTypeOf` and `doTypesOverlap` which now require a Schema as a first argument.

Commit:
6a1f23e1f9c1e6bf4cea837bc9bb6eae0fb5c382 [6a1f23e]
Parents:
a781b556ee
Author:
Lee Byron <[email protected]>
Date:
23 March 2016 at 1:17:43 PM SGT
Commit Date:
25 March 2016 at 6:35:39 AM SGT

Author: sogko

abstract_test.go

@@ -36,7 +36,7 @@ func TestIsTypeOfUsedToResolveRuntimeTypeForInterface(t *testing.T) {
 	})
 
 	// ie declare that Dog belongs to Pet interface
-	_ = graphql.NewObject(graphql.ObjectConfig{
+	dogType := graphql.NewObject(graphql.ObjectConfig{
 		Name: "Dog",
 		Interfaces: []*graphql.Interface{
 			petType,
@@ -67,7 +67,7 @@ func TestIsTypeOfUsedToResolveRuntimeTypeForInterface(t *testing.T) {
 		},
 	})
 	// ie declare that Cat belongs to Pet interface
-	_ = graphql.NewObject(graphql.ObjectConfig{
+	catType := graphql.NewObject(graphql.ObjectConfig{
 		Name: "Cat",
 		Interfaces: []*graphql.Interface{
 			petType,
@@ -112,6 +112,7 @@ func TestIsTypeOfUsedToResolveRuntimeTypeForInterface(t *testing.T) {
 				},
 			},
 		}),
+		Types: []graphql.Type{catType, dogType},
 	})
 	if err != nil {
 		t.Fatalf("Error in schema %v", err.Error())
@@ -288,12 +289,6 @@ func TestResolveTypeOnInterfaceYieldsUsefulError(t *testing.T) {
 		Fields: graphql.Fields{
 			"name": &graphql.Field{
 				Type: graphql.String,
-				Resolve: func(p graphql.ResolveParams) (interface{}, error) {
-					if human, ok := p.Source.(*testHuman); ok {
-						return human.Name, nil
-					}
-					return nil, nil
-				},
 			},
 		},
 	})
@@ -302,28 +297,12 @@ func TestResolveTypeOnInterfaceYieldsUsefulError(t *testing.T) {
 		Interfaces: []*graphql.Interface{
 			petType,
 		},
-		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{}, error) {
-					if dog, ok := p.Source.(*testDog); ok {
-						return dog.Name, nil
-					}
-					return nil, nil
-				},
 			},
 			"woofs": &graphql.Field{
 				Type: graphql.Boolean,
-				Resolve: func(p graphql.ResolveParams) (interface{}, error) {
-					if dog, ok := p.Source.(*testDog); ok {
-						return dog.Woofs, nil
-					}
-					return nil, nil
-				},
 			},
 		},
 	})
@@ -332,28 +311,12 @@ func TestResolveTypeOnInterfaceYieldsUsefulError(t *testing.T) {
 		Interfaces: []*graphql.Interface{
 			petType,
 		},
-		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{}, error) {
-					if cat, ok := p.Source.(*testCat); ok {
-						return cat.Name, nil
-					}
-					return nil, nil
-				},
 			},
 			"meows": &graphql.Field{
 				Type: graphql.Boolean,
-				Resolve: func(p graphql.ResolveParams) (interface{}, error) {
-					if cat, ok := p.Source.(*testCat); ok {
-						return cat.Meows, nil
-					}
-					return nil, nil
-				},
 			},
 		},
 	})
@@ -373,6 +336,7 @@ func TestResolveTypeOnInterfaceYieldsUsefulError(t *testing.T) {
 				},
 			},
 		}),
+		Types: []graphql.Type{catType, dogType},
 	})
 	if err != nil {
 		t.Fatalf("Error in schema %v", err.Error())

definition.go

@@ -143,13 +143,21 @@ func IsCompositeType(ttype interface{}) bool {
 // Abstract interface for types that may describe the parent context of a selection set.
 type Abstract interface {
 	Name() string
-	PossibleTypes() []*Object
-	IsPossibleType(ttype *Object) bool
 }
 
 var _ Abstract = (*Interface)(nil)
 var _ Abstract = (*Union)(nil)
 
+func IsAbstractType(ttype interface{}) bool {
+	if _, ok := ttype.(*Interface); ok {
+		return true
+	}
+	if _, ok := ttype.(*Union); ok {
+		return true
+	}
+	return false
+}
+
 // Nullable interface for types that can accept null as a value.
 type Nullable interface {
 }
@@ -393,21 +401,6 @@ func NewObject(config ObjectConfig) *Object {
 	objectType.IsTypeOf = config.IsTypeOf
 	objectType.typeConfig = config
 
-	/*
-			addImplementationToInterfaces()
-			Update the interfaces to know about this implementation.
-			This is an rare and unfortunate use of mutation in the type definition
-		 	implementations, but avoids an expensive "getPossibleTypes"
-		 	implementation for Interface
-	*/
-	interfaces := objectType.Interfaces()
-	if interfaces == nil {
-		return objectType
-	}
-	for _, iface := range interfaces {
-		iface.implementations = append(iface.implementations, objectType)
-	}
-
 	return objectType
 }
 func (gt *Object) AddFieldConfig(fieldName string, fieldConfig *Field) {
@@ -671,11 +664,8 @@ type Interface struct {
 	PrivateDescription string `json:"description"`
 	ResolveType        ResolveTypeFn
 
-	typeConfig      InterfaceConfig
-	fields          FieldDefinitionMap
-	implementations []*Object
-	possibleTypes   map[string]bool
-
+	typeConfig InterfaceConfig
+	fields     FieldDefinitionMap
 	err error
 }
 type InterfaceConfig struct {
@@ -704,7 +694,6 @@ func NewInterface(config InterfaceConfig) *Interface {
 	it.PrivateDescription = config.Description
 	it.ResolveType = config.ResolveType
 	it.typeConfig = config
-	it.implementations = []*Object{}
 
 	return it
 }
@@ -737,28 +726,6 @@ func (it *Interface) Fields() (fields FieldDefinitionMap) {
 	it.fields = fields
 	return it.fields
 }
-func (it *Interface) PossibleTypes() []*Object {
-	return it.implementations
-}
-func (it *Interface) IsPossibleType(ttype *Object) bool {
-	if ttype == nil {
-		return false
-	}
-	if len(it.possibleTypes) == 0 {
-		possibleTypes := map[string]bool{}
-		for _, possibleType := range it.PossibleTypes() {
-			if possibleType == nil {
-				continue
-			}
-			possibleTypes[possibleType.PrivateName] = true
-		}
-		it.possibleTypes = possibleTypes
-	}
-	if val, ok := it.possibleTypes[ttype.PrivateName]; ok {
-		return val
-	}
-	return false
-}
 func (it *Interface) String() string {
 	return it.PrivateName
 }
@@ -857,30 +824,9 @@ func NewUnion(config UnionConfig) *Union {
 
 	return objectType
 }
-func (ut *Union) PossibleTypes() []*Object {
+func (ut *Union) Types() []*Object {
 	return ut.types
 }
-func (ut *Union) IsPossibleType(ttype *Object) bool {
-
-	if ttype == nil {
-		return false
-	}
-	if len(ut.possibleTypes) == 0 {
-		possibleTypes := map[string]bool{}
-		for _, possibleType := range ut.PossibleTypes() {
-			if possibleType == nil {
-				continue
-			}
-			possibleTypes[possibleType.PrivateName] = true
-		}
-		ut.possibleTypes = possibleTypes
-	}
-
-	if val, ok := ut.possibleTypes[ttype.PrivateName]; ok {
-		return val
-	}
-	return false
-}
 func (ut *Union) String() string {
 	return ut.PrivateName
 }

definition_test.go

@@ -365,6 +365,7 @@ func TestTypeSystem_DefinitionExample_IncludesInterfacesSubTypesInTheTypeMap(t *
 				},
 			},
 		}),
+		Types: []graphql.Type{someSubType},
 	})
 	if err != nil {
 		t.Fatalf("unexpected error, got: %v", err)
@@ -408,6 +409,7 @@ func TestTypeSystem_DefinitionExample_IncludesInterfacesThunkSubtypesInTheTypeMa
 				},
 			},
 		}),
+		Types: []graphql.Type{someSubType},
 	})
 	if err != nil {
 		t.Fatalf("unexpected error, got: %v", err)

executor.go

@@ -425,8 +425,11 @@ func doesFragmentConditionMatch(eCtx *ExecutionContext, fragment ast.Node, ttype
 		if conditionalType.Name() == ttype.Name() {
 			return true
 		}
-		if conditionalType, ok := conditionalType.(Abstract); ok {
-			return conditionalType.IsPossibleType(ttype)
+		if conditionalType, ok := conditionalType.(*Interface); ok {
+			return eCtx.Schema.IsPossibleType(conditionalType, ttype)
+		}
+		if conditionalType, ok := conditionalType.(*Union); ok {
+			return eCtx.Schema.IsPossibleType(conditionalType, ttype)
 		}
 	case *ast.InlineFragment:
 		typeConditionAST := fragment.TypeCondition
@@ -443,8 +446,11 @@ func doesFragmentConditionMatch(eCtx *ExecutionContext, fragment ast.Node, ttype
 		if conditionalType.Name() == ttype.Name() {
 			return true
 		}
-		if conditionalType, ok := conditionalType.(Abstract); ok {
-			return conditionalType.IsPossibleType(ttype)
+		if conditionalType, ok := conditionalType.(*Interface); ok {
+			return eCtx.Schema.IsPossibleType(conditionalType, ttype)
+		}
+		if conditionalType, ok := conditionalType.(*Union); ok {
+			return eCtx.Schema.IsPossibleType(conditionalType, ttype)
 		}
 	}
 
@@ -539,6 +545,7 @@ func resolveField(eCtx *ExecutionContext, parentType *Object, source interface{}
 	result, resolveFnError = resolveFn(ResolveParams{
 		Source:  source,
 		Args:    args,
+		Schema:  eCtx.Schema,
 		Info:    info,
 		Context: eCtx.Context,
 	})
@@ -629,7 +636,10 @@ func completeValue(eCtx *ExecutionContext, returnType Type, fieldASTs []*ast.Fie
 
 	// If field type is an abstract type, Interface or Union, determine the
 	// runtime Object type and complete for that type.
-	if returnType, ok := returnType.(Abstract); ok {
+	if returnType, ok := returnType.(*Union); ok {
+		return completeAbstractValue(eCtx, returnType, fieldASTs, info, result)
+	}
+	if returnType, ok := returnType.(*Interface); ok {
 		return completeAbstractValue(eCtx, returnType, fieldASTs, info, result)
 	}
 
@@ -666,7 +676,7 @@ func completeAbstractValue(eCtx *ExecutionContext, returnType Abstract, fieldAST
 		return nil
 	}
 
-	if runtimeType != nil && !returnType.IsPossibleType(runtimeType) {
+	if runtimeType != nil && !eCtx.Schema.IsPossibleType(returnType, runtimeType) {
 		panic(gqlerrors.NewFormattedError(
 			fmt.Sprintf(`Runtime Object type "%v" is not a possible type `+
 				`for "%v".`, runtimeType, returnType),
@@ -758,7 +768,7 @@ func completeListValue(eCtx *ExecutionContext, returnType *List, fieldASTs []*as
 // used which tests each possible type for the abstract type by calling
 // isTypeOf for the object being coerced, returning the first type that matches.
 func defaultResolveTypeFn(value interface{}, info ResolveInfo, abstractType Abstract) *Object {
-	possibleTypes := abstractType.PossibleTypes()
+	possibleTypes := info.Schema.PossibleTypes(abstractType)
 	for _, possibleType := range possibleTypes {
 		if possibleType.IsTypeOf == nil {
 			continue

introspection.go

@@ -491,9 +491,9 @@ func init() {
 		Resolve: func(p ResolveParams) (interface{}, error) {
 			switch ttype := p.Source.(type) {
 			case *Interface:
-				return ttype.PossibleTypes(), nil
+				return p.Schema.PossibleTypes(ttype), nil
 			case *Union:
-				return ttype.PossibleTypes(), nil
+				return p.Schema.PossibleTypes(ttype), nil
 			}
 			return nil, nil
 		},