feat: Allow returning of errors from fields thunk (#2)

- Allow returning of errors from fields thunk

Author: AndrewSisley

definition.go

@@ -375,7 +375,7 @@ type ObjectConfig struct {
 	Description string      `json:"description"`
 }
 
-type FieldsThunk func() Fields
+type FieldsThunk func() (Fields, error)
 
 func NewObject(config ObjectConfig) *Object {
 	objectType := &Object{}
@@ -416,10 +416,11 @@ func (gt *Object) AddFieldConfig(fieldName string, fieldConfig *Field) {
 	case FieldsThunk:
 		// if the fields are defined as a thunk when the object is created
 		// then wrap the thunk in another thunk.
-		gt.typeConfig.Fields = (FieldsThunk)(func() Fields {
-			newFields := fields()
+		gt.typeConfig.Fields = (FieldsThunk)(func() (Fields, error) {
+			newFields, err := fields()
+			gt.err = err
 			newFields[fieldName] = fieldConfig
-			return newFields
+			return newFields, err
 		})
 		gt.initialisedFields = false
 	}
@@ -433,22 +434,36 @@ func (gt *Object) Description() string {
 func (gt *Object) String() string {
 	return gt.PrivateName
 }
+
 func (gt *Object) Fields() FieldDefinitionMap {
+	// We discard the returned error to preserve the orignal behaviour
+	// The error will still be added to the `gt.err` property
+	m, _ := gt.InitFields()
+	return m
+}
+
+func (gt *Object) InitFields() (FieldDefinitionMap, error) {
 	if gt.initialisedFields {
-		return gt.fields
+		return gt.fields, nil
 	}
 
 	var configureFields Fields
+	var err error
 	switch fields := gt.typeConfig.Fields.(type) {
 	case Fields:
 		configureFields = fields
 	case FieldsThunk:
-		configureFields = fields()
+		configureFields, err = fields()
+	}
+
+	if err != nil {
+		gt.err = err
+		return nil, err
 	}
 
 	gt.fields, gt.err = defineFieldMap(gt, configureFields)
 	gt.initialisedFields = true
-	return gt.fields
+	return gt.fields, nil
 }
 
 func (gt *Object) Interfaces() []*Interface {
@@ -753,21 +768,34 @@ func (it *Interface) Description() string {
 }
 
 func (it *Interface) Fields() (fields FieldDefinitionMap) {
+	// We discard the returned error to preserve the orignal behaviour
+	// The error will still be added to the `gt.err` property
+	m, _ := it.InitFields()
+	return m
+}
+
+func (it *Interface) InitFields() (FieldDefinitionMap, error) {
 	if it.initialisedFields {
-		return it.fields
+		return it.fields, nil
 	}
 
 	var configureFields Fields
+	var err error
 	switch fields := it.typeConfig.Fields.(type) {
 	case Fields:
 		configureFields = fields
 	case FieldsThunk:
-		configureFields = fields()
+		configureFields, err = fields()
+	}
+
+	if err != nil {
+		it.err = err
+		return nil, err
 	}
 
 	it.fields, it.err = defineFieldMap(it, configureFields)
 	it.initialisedFields = true
-	return it.fields
+	return it.fields, nil
 }
 
 func (it *Interface) String() string {

definition_test.go

@@ -604,15 +604,15 @@ func TestTypeSystem_DefinitionExample_IncludesFieldsThunk(t *testing.T) {
 	var someObject *graphql.Object
 	someObject = graphql.NewObject(graphql.ObjectConfig{
 		Name: "SomeObject",
-		Fields: (graphql.FieldsThunk)(func() graphql.Fields {
+		Fields: (graphql.FieldsThunk)(func() (graphql.Fields, error) {
 			return graphql.Fields{
 				"f": &graphql.Field{
 					Type: graphql.Int,
 				},
 				"s": &graphql.Field{
 					Type: someObject,
 				},
-			}
+			}, nil
 		}),
 	})
 	fieldMap := someObject.Fields()
@@ -624,15 +624,15 @@ func TestTypeSystem_DefinitionExample_IncludesFieldsThunk(t *testing.T) {
 func TestTypeSystem_DefinitionExampe_AllowsCyclicFieldTypes(t *testing.T) {
 	personType := graphql.NewObject(graphql.ObjectConfig{
 		Name: "Person",
-		Fields: (graphql.FieldsThunk)(func() graphql.Fields {
+		Fields: (graphql.FieldsThunk)(func() (graphql.Fields, error) {
 			return graphql.Fields{
 				"name": &graphql.Field{
 					Type: graphql.String,
 				},
 				"bestFriend": &graphql.Field{
 					Type: personType,
 				},
-			}
+			}, nil
 		}),
 	})
 

executor_test.go

@@ -2146,8 +2146,8 @@ func testErrors(t *testing.T, nameType graphql.Output, extensions map[string]int
 
 	heroType := graphql.NewObject(graphql.ObjectConfig{
 		Name: "Hero",
-		Fields: graphql.FieldsThunk(func() graphql.Fields {
-			return heroFields
+		Fields: graphql.FieldsThunk(func() (graphql.Fields, error) {
+			return heroFields, nil
 		}),
 	})
 

rules_overlapping_fields_can_be_merged_test.go

@@ -408,23 +408,23 @@ func init() {
 		ResolveType: func(p graphql.ResolveTypeParams) *graphql.Object {
 			return stringBoxObject
 		},
-		Fields: graphql.FieldsThunk(func() graphql.Fields {
+		Fields: graphql.FieldsThunk(func() (graphql.Fields, error) {
 			return graphql.Fields{
 				"deepBox": &graphql.Field{
 					Type: someBoxInterface,
 				},
 				"unrelatedField": &graphql.Field{
 					Type: graphql.String,
 				},
-			}
+			}, nil
 		}),
 	})
 	stringBoxObject = graphql.NewObject(graphql.ObjectConfig{
 		Name: "StringBox",
 		Interfaces: (graphql.InterfacesThunk)(func() []*graphql.Interface {
 			return []*graphql.Interface{someBoxInterface}
 		}),
-		Fields: graphql.FieldsThunk(func() graphql.Fields {
+		Fields: graphql.FieldsThunk(func() (graphql.Fields, error) {
 			return graphql.Fields{
 				"scalar": &graphql.Field{
 					Type: graphql.String,
@@ -444,15 +444,15 @@ func init() {
 				"intBox": &graphql.Field{
 					Type: intBoxObject,
 				},
-			}
+			}, nil
 		}),
 	})
 	intBoxObject = graphql.NewObject(graphql.ObjectConfig{
 		Name: "IntBox",
 		Interfaces: (graphql.InterfacesThunk)(func() []*graphql.Interface {
 			return []*graphql.Interface{someBoxInterface}
 		}),
-		Fields: graphql.FieldsThunk(func() graphql.Fields {
+		Fields: graphql.FieldsThunk(func() (graphql.Fields, error) {
 			return graphql.Fields{
 				"scalar": &graphql.Field{
 					Type: graphql.Int,
@@ -472,7 +472,7 @@ func init() {
 				"intBox": &graphql.Field{
 					Type: intBoxObject,
 				},
-			}
+			}, nil
 		}),
 	})
 	var nonNullStringBox1Interface = graphql.NewInterface(graphql.InterfaceConfig{

validation_test.go

@@ -1388,24 +1388,24 @@ func TestTypeSystem_ObjectsMustAdhereToInterfaceTheyImplement_AcceptsAnObjectWit
 		ResolveType: func(p graphql.ResolveTypeParams) *graphql.Object {
 			return nil
 		},
-		Fields: (graphql.FieldsThunk)(func() graphql.Fields {
+		Fields: (graphql.FieldsThunk)(func() (graphql.Fields, error) {
 			return graphql.Fields{
 				"field": &graphql.Field{
 					Type: anotherInterface,
 				},
-			}
+			}, nil
 		}),
 	})
 	var anotherObject *graphql.Object
 	anotherObject = graphql.NewObject(graphql.ObjectConfig{
 		Name:       "AnotherObject",
 		Interfaces: []*graphql.Interface{anotherInterface},
-		Fields: (graphql.FieldsThunk)(func() graphql.Fields {
+		Fields: (graphql.FieldsThunk)(func() (graphql.Fields, error) {
 			return graphql.Fields{
 				"field": &graphql.Field{
 					Type: anotherObject,
 				},
-			}
+			}, nil
 		}),
 	})
 	_, err := schemaWithFieldType(anotherObject)