@@ -0,0 +1,78 @@
+package graphql;
+
+import graphql.execution.ExecutionPath;
+import graphql.execution.ExecutionTypeInfo;
+import graphql.execution.UnresolvedTypeException;
+import graphql.language.SourceLocation;
+
+import java.util.List;
+
+import static graphql.Assert.assertNotNull;
+import static java.lang.String.format;
+
+@PublicApi
+public class UnresolvedTypeError implements GraphQLError {
+
+    private final String message;
+    private final List<Object> path;
+    private final UnresolvedTypeException exception;
+
+    public UnresolvedTypeError(ExecutionPath path, ExecutionTypeInfo info,
+                               UnresolvedTypeException exception) {
+        this.path = assertNotNull(path).toList();
+        this.exception = assertNotNull(exception);
+        this.message = mkMessage(path, exception, assertNotNull(info));
+    }
+
+    private String mkMessage(ExecutionPath path, UnresolvedTypeException exception, ExecutionTypeInfo info) {
+        return format("Can't resolve '%s'. Abstract type '%s' must resolve to an Object type at runtime for field '%s.%s'. %s",
+                path,
+                exception.getInterfaceOrUnionType().getName(),
+                info.getParentTypeInfo().getType().getName(),
+                info.getFieldDefinition().getName(),
+                exception.getMessage());
+    }
+
+    public UnresolvedTypeException getException() {
+        return exception;
+    }
+
+
+    @Override
+    public String getMessage() {
+        return message;
+    }
+
+    @Override
+    public List<SourceLocation> getLocations() {
+        return null;
+    }
+
+    @Override
+    public ErrorType getErrorType() {
+        return ErrorType.DataFetchingException;
+    }
+
+    public List<Object> getPath() {
+        return path;
+    }
+
+    @Override
+    public String toString() {
+        return "UnresolvedTypeError{" +
+                "path=" + path +
+                "exception=" + exception +
+                '}';
+    }
+
+    @SuppressWarnings("EqualsWhichDoesntCheckParameterClass")
+    @Override
+    public boolean equals(Object o) {
+        return GraphqlErrorHelper.equals(this, o);
+    }
+
+    @Override
+    public int hashCode() {
+        return GraphqlErrorHelper.hashCode(this);
+    }
+}
@@ -6,6 +6,7 @@
 import graphql.SerializationError;
 import graphql.TypeMismatchError;
 import graphql.TypeResolutionEnvironment;
+import graphql.UnresolvedTypeError;
 import graphql.execution.instrumentation.Instrumentation;
 import graphql.execution.instrumentation.InstrumentationContext;
 import graphql.execution.instrumentation.parameters.InstrumentationFieldCompleteParameters;
@@ -366,15 +367,34 @@ protected CompletableFuture<ExecutionResult> completeValue(ExecutionContext exec
         } else if (fieldType instanceof GraphQLEnumType) {
             return completeValueForEnum(executionContext, parameters, (GraphQLEnumType) fieldType, result);
         }
+
         //
         // when we are here, we have a complex type: Interface, Union or Object
         // and we must go deeper
         //
-        GraphQLObjectType resolvedObjectType = resolveType(executionContext, parameters, fieldType);
+        GraphQLObjectType resolvedObjectType;
+        try {
+            resolvedObjectType = resolveType(executionContext, parameters, fieldType);
+        } catch (UnresolvedTypeException ex) {
+            // consider the result to be null and add the error on the context
+            handleUnresolvedTypeProblem(executionContext, parameters, ex);
+            // and validate the field is nullable, if non-nullable throw exception
+            parameters.getNonNullFieldValidator().validate(parameters.getPath(), null);
+            // complete the field
+            return completedFuture(new ExecutionResultImpl(null, null));
+        }
 
         return completeValueForObject(executionContext, parameters, resolvedObjectType, result);
     }
 
+    private void handleUnresolvedTypeProblem(ExecutionContext context, ExecutionStrategyParameters parameters, UnresolvedTypeException e) {
+        UnresolvedTypeError error = new UnresolvedTypeError(parameters.getPath(), parameters.getTypeInfo(), e);
+        log.warn(error.getMessage(), e);
+        context.addError(error);
+
+        parameters.deferredErrorSupport().onError(error);
+    }
+
     private CompletableFuture<ExecutionResult> completeValueForNull(ExecutionStrategyParameters parameters) {
         Object nullValue = parameters.getNonNullFieldValidator().validate(parameters.getPath(), null);
         return completedFuture(new ExecutionResultImpl(nullValue, null));
@@ -659,9 +679,10 @@ protected GraphQLObjectType resolveType(ExecutionContext executionContext, Execu
      */
     protected GraphQLObjectType resolveTypeForInterface(TypeResolutionParameters params) {
         TypeResolutionEnvironment env = new TypeResolutionEnvironment(params.getValue(), params.getArgumentValues(), params.getField(), params.getGraphQLInterfaceType(), params.getSchema(), params.getContext());
-        GraphQLObjectType result = params.getGraphQLInterfaceType().getTypeResolver().getType(env);
+        GraphQLInterfaceType abstractType = params.getGraphQLInterfaceType();
+        GraphQLObjectType result = abstractType.getTypeResolver().getType(env);
         if (result == null) {
-            throw new UnresolvedTypeException(params.getGraphQLInterfaceType());
+            throw new UnresolvedTypeException(abstractType);
         }
         return result;
     }
@@ -675,9 +696,10 @@ protected GraphQLObjectType resolveTypeForInterface(TypeResolutionParameters par
      */
     protected GraphQLObjectType resolveTypeForUnion(TypeResolutionParameters params) {
         TypeResolutionEnvironment env = new TypeResolutionEnvironment(params.getValue(), params.getArgumentValues(), params.getField(), params.getGraphQLUnionType(), params.getSchema(), params.getContext());
-        GraphQLObjectType result = params.getGraphQLUnionType().getTypeResolver().getType(env);
+        GraphQLUnionType abstractType = params.getGraphQLUnionType();
+        GraphQLObjectType result = abstractType.getTypeResolver().getType(env);
         if (result == null) {
-            throw new UnresolvedTypeException(params.getGraphQLUnionType());
+            throw new UnresolvedTypeException(abstractType);
         }
         return result;
     }
 
@@ -13,12 +13,24 @@ public class UnresolvedTypeException extends GraphQLException {
 
     private final GraphQLOutputType interfaceOrUnionType;
 
-    public UnresolvedTypeException(GraphQLOutputType interfaceOrUnionType) {
-        super("Could not determine the exact type of '" + interfaceOrUnionType.getName() + "'");
+    /**
+     * Constructor to use a custom error message
+     * for an error that happened during type resolution.
+     *
+     * @param message              custom error message.
+     * @param interfaceOrUnionType expected type.
+     */
+    public UnresolvedTypeException(String message, GraphQLOutputType interfaceOrUnionType) {
+        super(message);
         this.interfaceOrUnionType = interfaceOrUnionType;
     }
 
+    public UnresolvedTypeException(GraphQLOutputType interfaceOrUnionType) {
+        this("Could not determine the exact type of '" + interfaceOrUnionType.getName() + "'", interfaceOrUnionType);
+    }
+
     public GraphQLOutputType getInterfaceOrUnionType() {
         return interfaceOrUnionType;
     }
+
 }