Improve performance by not eagerly formatting error messages for invariants

Author: Sebastian Friedel

definition.go

@@ -266,20 +266,20 @@ func NewScalar(config ScalarConfig) *Scalar {
 	st.PrivateName = config.Name
 	st.PrivateDescription = config.Description
 
-	err = invariant(
+	err = invariantf(
 		config.Serialize != nil,
-		fmt.Sprintf(`%v must provide "serialize" function. If this custom Scalar is `+
+		`%v must provide "serialize" function. If this custom Scalar is `+
 			`also used as an input type, ensure "parseValue" and "parseLiteral" `+
-			`functions are also provided.`, st),
+			`functions are also provided.`, st,
 	)
 	if err != nil {
 		st.err = err
 		return st
 	}
 	if config.ParseValue != nil || config.ParseLiteral != nil {
-		err = invariant(
+		err = invariantf(
 			config.ParseValue != nil && config.ParseLiteral != nil,
-			fmt.Sprintf(`%v must provide both "parseValue" and "parseLiteral" functions.`, st),
+			`%v must provide both "parseValue" and "parseLiteral" functions.`, st,
 		)
 		if err != nil {
 			st.err = err
@@ -478,20 +478,20 @@ func defineInterfaces(ttype *Object, interfaces []*Interface) ([]*Interface, err
 		return ifaces, nil
 	}
 	for _, iface := range interfaces {
-		err := invariant(
+		err := invariantf(
 			iface != nil,
-			fmt.Sprintf(`%v may only implement Interface types, it cannot implement: %v.`, ttype, iface),
+			`%v may only implement Interface types, it cannot implement: %v.`, ttype, iface,
 		)
 		if err != nil {
 			return ifaces, err
 		}
 		if iface.ResolveType != nil {
-			err = invariant(
+			err = invariantf(
 				iface.ResolveType != nil,
-				fmt.Sprintf(`Interface Type %v does not provide a "resolveType" function `+
+				`Interface Type %v does not provide a "resolveType" function `+
 					`and implementing Type %v does not provide a "isTypeOf" `+
 					`function. There is no way to resolve this implementing type `+
-					`during execution.`, iface, ttype),
+					`during execution.`, iface, ttype,
 			)
 			if err != nil {
 				return ifaces, err
@@ -507,9 +507,9 @@ func defineFieldMap(ttype Named, fields Fields) (FieldDefinitionMap, error) {
 
 	resultFieldMap := FieldDefinitionMap{}
 
-	err := invariant(
+	err := invariantf(
 		len(fields) > 0,
-		fmt.Sprintf(`%v fields must be an object with field names as keys or a function which return such an object.`, ttype),
+		`%v fields must be an object with field names as keys or a function which return such an object.`, ttype,
 	)
 	if err != nil {
 		return resultFieldMap, err
@@ -519,9 +519,9 @@ func defineFieldMap(ttype Named, fields Fields) (FieldDefinitionMap, error) {
 		if field == nil {
 			continue
 		}
-		err = invariant(
+		err = invariantf(
 			field.Type != nil,
-			fmt.Sprintf(`%v.%v field type must be Output Type but got: %v.`, ttype, fieldName, field.Type),
+			`%v.%v field type must be Output Type but got: %v.`, ttype, fieldName, field.Type,
 		)
 		if err != nil {
 			return resultFieldMap, err
@@ -547,16 +547,16 @@ func defineFieldMap(ttype Named, fields Fields) (FieldDefinitionMap, error) {
 			if err != nil {
 				return resultFieldMap, err
 			}
-			err = invariant(
+			err = invariantf(
 				arg != nil,
-				fmt.Sprintf(`%v.%v args must be an object with argument names as keys.`, ttype, fieldName),
+				`%v.%v args must be an object with argument names as keys.`, ttype, fieldName,
 			)
 			if err != nil {
 				return resultFieldMap, err
 			}
-			err = invariant(
+			err = invariantf(
 				arg.Type != nil,
-				fmt.Sprintf(`%v.%v(%v:) argument type must be Input Type but got: %v.`, ttype, fieldName, argName, arg.Type),
+				`%v.%v(%v:) argument type must be Input Type but got: %v.`, ttype, fieldName, argName, arg.Type,
 			)
 			if err != nil {
 				return resultFieldMap, err
@@ -823,30 +823,30 @@ func NewUnion(config UnionConfig) *Union {
 	objectType.PrivateDescription = config.Description
 	objectType.ResolveType = config.ResolveType
 
-	err = invariant(
+	err = invariantf(
 		len(config.Types) > 0,
-		fmt.Sprintf(`Must provide Array of types for Union %v.`, config.Name),
+		`Must provide Array of types for Union %v.`, config.Name,
 	)
 	if err != nil {
 		objectType.err = err
 		return objectType
 	}
 	for _, ttype := range config.Types {
-		err := invariant(
+		err := invariantf(
 			ttype != nil,
-			fmt.Sprintf(`%v may only contain Object types, it cannot contain: %v.`, objectType, ttype),
+			`%v may only contain Object types, it cannot contain: %v.`, objectType, ttype,
 		)
 		if err != nil {
 			objectType.err = err
 			return objectType
 		}
 		if objectType.ResolveType == nil {
-			err = invariant(
+			err = invariantf(
 				ttype.IsTypeOf != nil,
-				fmt.Sprintf(`Union Type %v does not provide a "resolveType" function `+
+				`Union Type %v does not provide a "resolveType" function `+
 					`and possible Type %v does not provide a "isTypeOf" `+
 					`function. There is no way to resolve this possible type `+
-					`during execution.`, objectType, ttype),
+					`during execution.`, objectType, ttype,
 			)
 			if err != nil {
 				objectType.err = err
@@ -947,19 +947,19 @@ func NewEnum(config EnumConfig) *Enum {
 func (gt *Enum) defineEnumValues(valueMap EnumValueConfigMap) ([]*EnumValueDefinition, error) {
 	values := []*EnumValueDefinition{}
 
-	err := invariant(
+	err := invariantf(
 		len(valueMap) > 0,
-		fmt.Sprintf(`%v values must be an object with value names as keys.`, gt),
+		`%v values must be an object with value names as keys.`, gt,
 	)
 	if err != nil {
 		return values, err
 	}
 
 	for valueName, valueConfig := range valueMap {
-		err := invariant(
+		err := invariantf(
 			valueConfig != nil,
-			fmt.Sprintf(`%v.%v must refer to an object with a "value" key `+
-				`representing an internal value but got: %v.`, gt, valueName, valueConfig),
+			`%v.%v must refer to an object with a "value" key `+
+				`representing an internal value but got: %v.`, gt, valueName, valueConfig,
 		)
 		if err != nil {
 			return values, err
@@ -1130,9 +1130,9 @@ func (gt *InputObject) defineFieldMap() InputObjectFieldMap {
 	}
 	resultFieldMap := InputObjectFieldMap{}
 
-	err := invariant(
+	err := invariantf(
 		len(fieldMap) > 0,
-		fmt.Sprintf(`%v fields must be an object with field names as keys or a function which return such an object.`, gt),
+		`%v fields must be an object with field names as keys or a function which return such an object.`, gt,
 	)
 	if err != nil {
 		gt.err = err
@@ -1147,9 +1147,9 @@ func (gt *InputObject) defineFieldMap() InputObjectFieldMap {
 		if err != nil {
 			continue
 		}
-		err = invariant(
+		err = invariantf(
 			fieldConfig.Type != nil,
-			fmt.Sprintf(`%v.%v field type must be Input Type but got: %v.`, gt, fieldName, fieldConfig.Type),
+			`%v.%v field type must be Input Type but got: %v.`, gt, fieldName, fieldConfig.Type,
 		)
 		if err != nil {
 			gt.err = err
@@ -1205,7 +1205,7 @@ type List struct {
 func NewList(ofType Type) *List {
 	gl := &List{}
 
-	err := invariant(ofType != nil, fmt.Sprintf(`Can only create List of a Type but got: %v.`, ofType))
+	err := invariantf(ofType != nil, `Can only create List of a Type but got: %v.`, ofType)
 	if err != nil {
 		gl.err = err
 		return gl
@@ -1259,7 +1259,7 @@ func NewNonNull(ofType Type) *NonNull {
 	gl := &NonNull{}
 
 	_, isOfTypeNonNull := ofType.(*NonNull)
-	err := invariant(ofType != nil && !isOfTypeNonNull, fmt.Sprintf(`Can only create NonNull of a Nullable Type but got: %v.`, ofType))
+	err := invariantf(ofType != nil && !isOfTypeNonNull, `Can only create NonNull of a Nullable Type but got: %v.`, ofType)
 	if err != nil {
 		gl.err = err
 		return gl
@@ -1286,8 +1286,8 @@ func (gl *NonNull) Error() error {
 var NameRegExp, _ = regexp.Compile("^[_a-zA-Z][_a-zA-Z0-9]*$")
 
 func assertValidName(name string) error {
-	return invariant(
+	return invariantf(
 		NameRegExp.MatchString(name),
-		fmt.Sprintf(`Names must match /^[_a-zA-Z][_a-zA-Z0-9]*$/ but "%v" does not.`, name),
+		`Names must match /^[_a-zA-Z][_a-zA-Z0-9]*$/ but "%v" does not.`, name,
 	)
 }

executor.go

@@ -635,9 +635,7 @@ func completeValue(eCtx *ExecutionContext, returnType Type, fieldASTs []*ast.Fie
 	}
 
 	// Not reachable. All possible output types have been considered.
-	err := invariant(false,
-		fmt.Sprintf(`Cannot complete value of unexpected type "%v."`, returnType),
-	)
+	err := invariantf(false, `Cannot complete value of unexpected type "%v."`, returnType)
 	if err != nil {
 		panic(gqlerrors.FormatError(err))
 	}
@@ -663,8 +661,9 @@ func completeAbstractValue(eCtx *ExecutionContext, returnType Abstract, fieldAST
 		runtimeType = defaultResolveTypeFn(resolveTypeParams, returnType)
 	}
 
-	err := invariant(runtimeType != nil,
-		fmt.Sprintf(`Could not determine runtime type of value "%v" for field %v.%v.`, result, info.ParentType, info.FieldName),
+	err := invariantf(runtimeType != nil,
+		`Could not determine runtime type of value "%v" for field %v.%v.`,
+		result, info.ParentType, info.FieldName,
 	)
 	if err != nil {
 		panic(err)
@@ -746,10 +745,10 @@ func completeListValue(eCtx *ExecutionContext, returnType *List, fieldASTs []*as
 	if info.ParentType != nil {
 		parentTypeName = info.ParentType.Name()
 	}
-	err := invariant(
+	err := invariantf(
 		resultVal.IsValid() && resultVal.Type().Kind() == reflect.Slice,
-		fmt.Sprintf("User Error: expected iterable, but did not find one "+
-			"for field %v.%v.", parentTypeName, info.FieldName),
+		"User Error: expected iterable, but did not find one "+
+			"for field %v.%v.", parentTypeName, info.FieldName,
 	)
 	if err != nil {
 		panic(gqlerrors.FormatError(err))

schema.go

@@ -1,9 +1,5 @@
 package graphql
 
-import (
-	"fmt"
-)
-
 type SchemaConfig struct {
 	Query        *Object
 	Mutation     *Object
@@ -224,9 +220,9 @@ func typeMapReducer(schema *Schema, typeMap TypeMap, objectType Type) (TypeMap,
 	}
 
 	if mappedObjectType, ok := typeMap[objectType.Name()]; ok {
-		err := invariant(
+		err := invariantf(
 			mappedObjectType == objectType,
-			fmt.Sprintf(`Schema must contain unique named types but contains multiple types named "%v".`, objectType.Name()),
+			`Schema must contain unique named types but contains multiple types named "%v".`, objectType.Name(),
 		)
 		if err != nil {
 			return typeMap, err
@@ -344,23 +340,23 @@ func assertObjectImplementsInterface(schema *Schema, object *Object, iface *Inte
 		ifaceField := ifaceFieldMap[fieldName]
 
 		// Assert interface field exists on object.
-		err := invariant(
+		err := invariantf(
 			objectField != nil,
-			fmt.Sprintf(`"%v" expects field "%v" but "%v" does not `+
-				`provide it.`, iface, fieldName, object),
+			`"%v" expects field "%v" but "%v" does not `+
+				`provide it.`, iface, fieldName, object,
 		)
 		if err != nil {
 			return err
 		}
 
 		// Assert interface field type is satisfied by object field type, by being
 		// a valid subtype. (covariant)
-		err = invariant(
+		err = invariantf(
 			isTypeSubTypeOf(schema, objectField.Type, ifaceField.Type),
-			fmt.Sprintf(`%v.%v expects type "%v" but `+
+			`%v.%v expects type "%v" but `+
 				`%v.%v provides type "%v".`,
-				iface, fieldName, ifaceField.Type,
-				object, fieldName, objectField.Type),
+			iface, fieldName, ifaceField.Type,
+			object, fieldName, objectField.Type,
 		)
 		if err != nil {
 			return err
@@ -377,27 +373,26 @@ func assertObjectImplementsInterface(schema *Schema, object *Object, iface *Inte
 				}
 			}
 			// Assert interface field arg exists on object field.
-			err = invariant(
+			err = invariantf(
 				objectArg != nil,
-				fmt.Sprintf(`%v.%v expects argument "%v" but `+
+				`%v.%v expects argument "%v" but `+
 					`%v.%v does not provide it.`,
-					iface, fieldName, argName,
-					object, fieldName),
+				iface, fieldName, argName,
+				object, fieldName,
 			)
 			if err != nil {
 				return err
 			}
 
 			// Assert interface field arg type matches object field arg type.
 			// (invariant)
-			err = invariant(
+			err = invariantf(
 				isEqualType(ifaceArg.Type, objectArg.Type),
-				fmt.Sprintf(
-					`%v.%v(%v:) expects type "%v" `+
-						`but %v.%v(%v:) provides `+
-						`type "%v".`,
-					iface, fieldName, argName, ifaceArg.Type,
-					object, fieldName, argName, objectArg.Type),
+				`%v.%v(%v:) expects type "%v" `+
+					`but %v.%v(%v:) provides `+
+					`type "%v".`,
+				iface, fieldName, argName, ifaceArg.Type,
+				object, fieldName, argName, objectArg.Type,
 			)
 			if err != nil {
 				return err
@@ -416,12 +411,12 @@ func assertObjectImplementsInterface(schema *Schema, object *Object, iface *Inte
 
 			if ifaceArg == nil {
 				_, ok := objectArg.Type.(*NonNull)
-				err = invariant(
+				err = invariantf(
 					!ok,
-					fmt.Sprintf(`%v.%v(%v:) is of required type `+
+					`%v.%v(%v:) is of required type `+
 						`"%v" but is not also provided by the interface %v.%v.`,
-						object, fieldName, argName,
-						objectArg.Type, iface, fieldName),
+					object, fieldName, argName,
+					objectArg.Type, iface, fieldName,
 				)
 				if err != nil {
 					return err

values.go

@@ -7,11 +7,12 @@ import (
 	"reflect"
 	"strings"
 
+	"sort"
+
 	"github.com/graphql-go/graphql/gqlerrors"
 	"github.com/graphql-go/graphql/language/ast"
 	"github.com/graphql-go/graphql/language/kinds"
 	"github.com/graphql-go/graphql/language/printer"
-	"sort"
 )
 
 // Prepares an object map of variableValues of the correct type based on the
@@ -442,3 +443,10 @@ func invariant(condition bool, message string) error {
 	}
 	return nil
 }
+
+func invariantf(condition bool, message string, args ...interface{}) error {
+	if !condition {
+		return gqlerrors.NewFormattedError(fmt.Sprintf(message, args...))
+	}
+	return nil
+}