graphql 15.2.0 → 15.5.0

package/execution/execute.js.flow

@@ -1,7 +1,4 @@
 // @flow strict
-
-import arrayFrom from '../polyfills/arrayFrom';
-
 import type { Path } from '../jsutils/Path';
 import type { ObjMap } from '../jsutils/ObjMap';
 import type { PromiseOrValue } from '../jsutils/PromiseOrValue';
@@ -11,11 +8,12 @@ import invariant from '../jsutils/invariant';
 import devAssert from '../jsutils/devAssert';
 import isPromise from '../jsutils/isPromise';
 import isObjectLike from '../jsutils/isObjectLike';
-import isCollection from '../jsutils/isCollection';
+import safeArrayFrom from '../jsutils/safeArrayFrom';
 import promiseReduce from '../jsutils/promiseReduce';
 import promiseForObject from '../jsutils/promiseForObject';
 import { addPath, pathToArray } from '../jsutils/Path';
 
+import type { GraphQLFormattedError } from '../error/formatError';
 import { GraphQLError } from '../error/GraphQLError';
 import { locatedError } from '../error/locatedError';
 
@@ -53,6 +51,7 @@ import {
   GraphQLSkipDirective,
 } from '../type/directives';
 import {
+  isNamedType,
   isObjectType,
   isAbstractType,
   isLeafType,
@@ -120,6 +119,12 @@ export type ExecutionResult = {|
   extensions?: ObjMap<mixed>,
 |};
 
+export type FormattedExecutionResult = {|
+  errors?: $ReadOnlyArray<GraphQLFormattedError>,
+  data?: ObjMap<mixed> | null,
+  extensions?: ObjMap<mixed>,
+|};
+
 export type ExecutionArgs = {|
   schema: GraphQLSchema,
   document: DocumentNode,
@@ -381,8 +386,6 @@ function executeOperation(
   // Errors from sub-fields of a NonNull type may propagate to the top level,
   // at which point we still log the error and null the parent field, which
   // in this case is the entire response.
-  //
-  // Similar to completeValueCatchingError.
   try {
     const result =
       operation.operation === 'mutation'
@@ -467,7 +470,7 @@ function executeFields(
 
     if (result !== undefined) {
       results[responseName] = result;
-      if (!containsPromise && isPromise(result)) {
+      if (isPromise(result)) {
         containsPromise = true;
       }
     }
@@ -638,6 +641,7 @@ function resolveField(
     return;
   }
 
+  const returnType = fieldDef.type;
   const resolveFn = fieldDef.resolve ?? exeContext.fieldResolver;
 
   const info = buildResolveInfo(
@@ -648,67 +652,7 @@ function resolveField(
     path,
   );
 
-  // Get the resolve function, regardless of if its result is normal
-  // or abrupt (error).
-  const result = resolveFieldValueOrError(
-    exeContext,
-    fieldDef,
-    fieldNodes,
-    resolveFn,
-    source,
-    info,
-  );
-
-  return completeValueCatchingError(
-    exeContext,
-    fieldDef.type,
-    fieldNodes,
-    info,
-    path,
-    result,
-  );
-}
-
-/**
- * @internal
- */
-export function buildResolveInfo(
-  exeContext: ExecutionContext,
-  fieldDef: GraphQLField<mixed, mixed>,
-  fieldNodes: $ReadOnlyArray<FieldNode>,
-  parentType: GraphQLObjectType,
-  path: Path,
-): GraphQLResolveInfo {
-  // The resolve function's optional fourth argument is a collection of
-  // information about the current execution state.
-  return {
-    fieldName: fieldDef.name,
-    fieldNodes,
-    returnType: fieldDef.type,
-    parentType,
-    path,
-    schema: exeContext.schema,
-    fragments: exeContext.fragments,
-    rootValue: exeContext.rootValue,
-    operation: exeContext.operation,
-    variableValues: exeContext.variableValues,
-  };
-}
-
-/**
- * Isolates the "ReturnOrAbrupt" behavior to not de-opt the `resolveField`
- * function. Returns the result of resolveFn or the abrupt-return Error object.
- *
- * @internal
- */
-export function resolveFieldValueOrError(
-  exeContext: ExecutionContext,
-  fieldDef: GraphQLField<mixed, mixed>,
-  fieldNodes: $ReadOnlyArray<FieldNode>,
-  resolveFn: GraphQLFieldResolver<mixed, mixed>,
-  source: mixed,
-  info: GraphQLResolveInfo,
-): Error | mixed {
+  // Get the resolve function, regardless of if its result is normal or abrupt (error).
   try {
     // Build a JS object of arguments from the field.arguments AST, using the
     // variables scope to fulfill any variable references.
@@ -725,32 +669,7 @@ export function resolveFieldValueOrError(
     const contextValue = exeContext.contextValue;
 
     const result = resolveFn(source, args, contextValue, info);
-    return isPromise(result) ? result.then(undefined, asErrorInstance) : result;
-  } catch (error) {
-    return asErrorInstance(error);
-  }
-}
-
-// Sometimes a non-error is thrown, wrap it as an Error instance to ensure a
-// consistent Error interface.
-function asErrorInstance(error: mixed): Error {
-  if (error instanceof Error) {
-    return error;
-  }
-  return new Error('Unexpected error value: ' + inspect(error));
-}
 
-// This is a small wrapper around completeValue which detects and logs errors
-// in the execution context.
-function completeValueCatchingError(
-  exeContext: ExecutionContext,
-  returnType: GraphQLOutputType,
-  fieldNodes: $ReadOnlyArray<FieldNode>,
-  info: GraphQLResolveInfo,
-  path: Path,
-  result: mixed,
-): PromiseOrValue<mixed> {
-  try {
     let completed;
     if (isPromise(result)) {
       completed = result.then((resolved) =>
@@ -770,23 +689,49 @@ function completeValueCatchingError(
     if (isPromise(completed)) {
       // Note: we don't rely on a `catch` method, but we do expect "thenable"
       // to take a second callback for the error case.
-      return completed.then(undefined, (error) =>
-        handleFieldError(error, fieldNodes, path, returnType, exeContext),
-      );
+      return completed.then(undefined, (rawError) => {
+        const error = locatedError(rawError, fieldNodes, pathToArray(path));
+        return handleFieldError(error, returnType, exeContext);
+      });
     }
     return completed;
-  } catch (error) {
-    return handleFieldError(error, fieldNodes, path, returnType, exeContext);
+  } catch (rawError) {
+    const error = locatedError(rawError, fieldNodes, pathToArray(path));
+    return handleFieldError(error, returnType, exeContext);
   }
 }
 
-function handleFieldError(rawError, fieldNodes, path, returnType, exeContext) {
-  const error = locatedError(
-    asErrorInstance(rawError),
+/**
+ * @internal
+ */
+export function buildResolveInfo(
+  exeContext: ExecutionContext,
+  fieldDef: GraphQLField<mixed, mixed>,
+  fieldNodes: $ReadOnlyArray<FieldNode>,
+  parentType: GraphQLObjectType,
+  path: Path,
+): GraphQLResolveInfo {
+  // The resolve function's optional fourth argument is a collection of
+  // information about the current execution state.
+  return {
+    fieldName: fieldDef.name,
     fieldNodes,
-    pathToArray(path),
-  );
+    returnType: fieldDef.type,
+    parentType,
+    path,
+    schema: exeContext.schema,
+    fragments: exeContext.fragments,
+    rootValue: exeContext.rootValue,
+    operation: exeContext.operation,
+    variableValues: exeContext.variableValues,
+  };
+}
 
+function handleFieldError(
+  error: GraphQLError,
+  returnType: GraphQLOutputType,
+  exeContext: ExecutionContext,
+): null {
   // If the field type is non-nullable, then it is resolved without any
   // protection from errors, however it still properly locates the error.
   if (isNonNullType(returnType)) {
@@ -921,36 +866,64 @@ function completeListValue(
   path: Path,
   result: mixed,
 ): PromiseOrValue<$ReadOnlyArray<mixed>> {
-  if (!isCollection(result)) {
-    throw new GraphQLError(
-      `Expected Iterable, but did not find one for field "${info.parentType.name}.${info.fieldName}".`,
-    );
-  }
-
   // This is specified as a simple map, however we're optimizing the path
   // where the list contains no Promises by avoiding creating another Promise.
   const itemType = returnType.ofType;
   let containsPromise = false;
-  const completedResults = arrayFrom(result, (item, index) => {
+  const completedResults = safeArrayFrom(result, (item, index) => {
     // No need to modify the info object containing the path,
     // since from here on it is not ever accessed by resolver functions.
-    const fieldPath = addPath(path, index, undefined);
-    const completedItem = completeValueCatchingError(
-      exeContext,
-      itemType,
-      fieldNodes,
-      info,
-      fieldPath,
-      item,
-    );
+    const itemPath = addPath(path, index, undefined);
+    try {
+      let completedItem;
+      if (isPromise(item)) {
+        completedItem = item.then((resolved) =>
+          completeValue(
+            exeContext,
+            itemType,
+            fieldNodes,
+            info,
+            itemPath,
+            resolved,
+          ),
+        );
+      } else {
+        completedItem = completeValue(
+          exeContext,
+          itemType,
+          fieldNodes,
+          info,
+          itemPath,
+          item,
+        );
+      }
 
-    if (!containsPromise && isPromise(completedItem)) {
-      containsPromise = true;
+      if (isPromise(completedItem)) {
+        containsPromise = true;
+        // Note: we don't rely on a `catch` method, but we do expect "thenable"
+        // to take a second callback for the error case.
+        return completedItem.then(undefined, (rawError) => {
+          const error = locatedError(
+            rawError,
+            fieldNodes,
+            pathToArray(itemPath),
+          );
+          return handleFieldError(error, itemType, exeContext);
+        });
+      }
+      return completedItem;
+    } catch (rawError) {
+      const error = locatedError(rawError, fieldNodes, pathToArray(itemPath));
+      return handleFieldError(error, itemType, exeContext);
     }
-
-    return completedItem;
   });
 
+  if (completedResults == null) {
+    throw new GraphQLError(
+      `Expected Iterable, but did not find one for field "${info.parentType.name}.${info.fieldName}".`,
+    );
+  }
+
   return containsPromise ? Promise.all(completedResults) : completedResults;
 }
 
@@ -1023,23 +996,43 @@ function completeAbstractValue(
 }
 
 function ensureValidRuntimeType(
-  runtimeTypeOrName: ?GraphQLObjectType | string,
+  runtimeTypeOrName: mixed,
   exeContext: ExecutionContext,
   returnType: GraphQLAbstractType,
   fieldNodes: $ReadOnlyArray<FieldNode>,
   info: GraphQLResolveInfo,
   result: mixed,
 ): GraphQLObjectType {
-  const runtimeType =
-    typeof runtimeTypeOrName === 'string'
-      ? exeContext.schema.getType(runtimeTypeOrName)
-      : runtimeTypeOrName;
+  if (runtimeTypeOrName == null) {
+    throw new GraphQLError(
+      `Abstract type "${returnType.name}" must resolve to an Object type at runtime for field "${info.parentType.name}.${info.fieldName}". Either the "${returnType.name}" type should provide a "resolveType" function or each possible type should provide an "isTypeOf" function.`,
+      fieldNodes,
+    );
+  }
 
-  if (!isObjectType(runtimeType)) {
+  // FIXME: temporary workaround until support for passing object types would be removed in v16.0.0
+  const runtimeTypeName = isNamedType(runtimeTypeOrName)
+    ? runtimeTypeOrName.name
+    : runtimeTypeOrName;
+
+  if (typeof runtimeTypeName !== 'string') {
     throw new GraphQLError(
       `Abstract type "${returnType.name}" must resolve to an Object type at runtime for field "${info.parentType.name}.${info.fieldName}" with ` +
-        `value ${inspect(result)}, received "${inspect(runtimeType)}". ` +
-        `Either the "${returnType.name}" type should provide a "resolveType" function or each possible type should provide an "isTypeOf" function.`,
+        `value ${inspect(result)}, received "${inspect(runtimeTypeOrName)}".`,
+    );
+  }
+
+  const runtimeType = exeContext.schema.getType(runtimeTypeName);
+  if (runtimeType == null) {
+    throw new GraphQLError(
+      `Abstract type "${returnType.name}" was resolve to a type "${runtimeTypeName}" that does not exist inside schema.`,
+      fieldNodes,
+    );
+  }
+
+  if (!isObjectType(runtimeType)) {
+    throw new GraphQLError(
+      `Abstract type "${returnType.name}" was resolve to a non-object type "${runtimeTypeName}".`,
       fieldNodes,
     );
   }
@@ -1184,7 +1177,7 @@ export const defaultTypeResolver: GraphQLTypeResolver<mixed, mixed> = function (
       if (isPromise(isTypeOfResult)) {
         promisedIsTypeOfResults[i] = isTypeOfResult;
       } else if (isTypeOfResult) {
-        return type;
+        return type.name;
       }
     }
   }
@@ -1193,7 +1186,7 @@ export const defaultTypeResolver: GraphQLTypeResolver<mixed, mixed> = function (
     return Promise.all(promisedIsTypeOfResults).then((isTypeOfResults) => {
       for (let i = 0; i < isTypeOfResults.length; i++) {
         if (isTypeOfResults[i]) {
-          return possibleTypes[i];
+          return possibleTypes[i].name;
         }
       }
     });
@@ -1222,12 +1215,12 @@ export const defaultFieldResolver: GraphQLFieldResolver<
 
 /**
  * This method looks up the field on the given type definition.
- * It has special casing for the two introspection fields, __schema
- * and __typename. __typename is special because it can always be
- * queried as a field, even in situations where no other fields
- * are allowed, like on a Union. __schema could get automatically
- * added to the query type, but that would require mutating type
- * definitions, which would cause issues.
+ * It has special casing for the three introspection fields,
+ * __schema, __type and __typename. __typename is special because
+ * it can always be queried as a field, even in situations where no
+ * other fields are allowed, like on a Union. __schema and __type
+ * could get automatically added to the query type, but that would
+ * require mutating type definitions, which would cause issues.
  *
  * @internal
  */

package/execution/execute.mjs

@@ -1,11 +1,10 @@
-import arrayFrom from "../polyfills/arrayFrom.mjs";
 import inspect from "../jsutils/inspect.mjs";
 import memoize3 from "../jsutils/memoize3.mjs";
 import invariant from "../jsutils/invariant.mjs";
 import devAssert from "../jsutils/devAssert.mjs";
 import isPromise from "../jsutils/isPromise.mjs";
 import isObjectLike from "../jsutils/isObjectLike.mjs";
-import isCollection from "../jsutils/isCollection.mjs";
+import safeArrayFrom from "../jsutils/safeArrayFrom.mjs";
 import promiseReduce from "../jsutils/promiseReduce.mjs";
 import promiseForObject from "../jsutils/promiseForObject.mjs";
 import { addPath, pathToArray } from "../jsutils/Path.mjs";
@@ -15,7 +14,7 @@ import { Kind } from "../language/kinds.mjs";
 import { assertValidSchema } from "../type/validate.mjs";
 import { SchemaMetaFieldDef, TypeMetaFieldDef, TypeNameMetaFieldDef } from "../type/introspection.mjs";
 import { GraphQLIncludeDirective, GraphQLSkipDirective } from "../type/directives.mjs";
-import { isObjectType, isAbstractType, isLeafType, isListType, isNonNullType } from "../type/definition.mjs";
+import { isNamedType, isObjectType, isAbstractType, isLeafType, isListType, isNonNullType } from "../type/definition.mjs";
 import { typeFromAST } from "../utilities/typeFromAST.mjs";
 import { getOperationRootType } from "../utilities/getOperationRootType.mjs";
 import { getVariableValues, getArgumentValues, getDirectiveValues } from "./values.mjs";
@@ -220,8 +219,6 @@ function executeOperation(exeContext, operation, rootValue) {
   var path = undefined; // Errors from sub-fields of a NonNull type may propagate to the top level,
   // at which point we still log the error and null the parent field, which
   // in this case is the entire response.
-  //
-  // Similar to completeValueCatchingError.
 
   try {
     var result = operation.operation === 'mutation' ? executeFieldsSerially(exeContext, type, rootValue, path, fields) : executeFields(exeContext, type, rootValue, path, fields);
@@ -285,7 +282,7 @@ function executeFields(exeContext, parentType, sourceValue, path, fields) {
     if (result !== undefined) {
       results[responseName] = result;
 
-      if (!containsPromise && isPromise(result)) {
+      if (isPromise(result)) {
         containsPromise = true;
       }
     }
@@ -438,42 +435,10 @@ function resolveField(exeContext, parentType, source, fieldNodes, path) {
     return;
   }
 
+  var returnType = fieldDef.type;
   var resolveFn = (_fieldDef$resolve = fieldDef.resolve) !== null && _fieldDef$resolve !== void 0 ? _fieldDef$resolve : exeContext.fieldResolver;
-  var info = buildResolveInfo(exeContext, fieldDef, fieldNodes, parentType, path); // Get the resolve function, regardless of if its result is normal
-  // or abrupt (error).
-
-  var result = resolveFieldValueOrError(exeContext, fieldDef, fieldNodes, resolveFn, source, info);
-  return completeValueCatchingError(exeContext, fieldDef.type, fieldNodes, info, path, result);
-}
-/**
- * @internal
- */
-
-
-export function buildResolveInfo(exeContext, fieldDef, fieldNodes, parentType, path) {
-  // The resolve function's optional fourth argument is a collection of
-  // information about the current execution state.
-  return {
-    fieldName: fieldDef.name,
-    fieldNodes: fieldNodes,
-    returnType: fieldDef.type,
-    parentType: parentType,
-    path: path,
-    schema: exeContext.schema,
-    fragments: exeContext.fragments,
-    rootValue: exeContext.rootValue,
-    operation: exeContext.operation,
-    variableValues: exeContext.variableValues
-  };
-}
-/**
- * Isolates the "ReturnOrAbrupt" behavior to not de-opt the `resolveField`
- * function. Returns the result of resolveFn or the abrupt-return Error object.
- *
- * @internal
- */
+  var info = buildResolveInfo(exeContext, fieldDef, fieldNodes, parentType, path); // Get the resolve function, regardless of if its result is normal or abrupt (error).
 
-export function resolveFieldValueOrError(exeContext, fieldDef, fieldNodes, resolveFn, source, info) {
   try {
     // Build a JS object of arguments from the field.arguments AST, using the
     // variables scope to fulfill any variable references.
@@ -484,25 +449,6 @@ export function resolveFieldValueOrError(exeContext, fieldDef, fieldNodes, resol
 
     var _contextValue = exeContext.contextValue;
     var result = resolveFn(source, args, _contextValue, info);
-    return isPromise(result) ? result.then(undefined, asErrorInstance) : result;
-  } catch (error) {
-    return asErrorInstance(error);
-  }
-} // Sometimes a non-error is thrown, wrap it as an Error instance to ensure a
-// consistent Error interface.
-
-function asErrorInstance(error) {
-  if (error instanceof Error) {
-    return error;
-  }
-
-  return new Error('Unexpected error value: ' + inspect(error));
-} // This is a small wrapper around completeValue which detects and logs errors
-// in the execution context.
-
-
-function completeValueCatchingError(exeContext, returnType, fieldNodes, info, path, result) {
-  try {
     var completed;
 
     if (isPromise(result)) {
@@ -516,21 +462,43 @@ function completeValueCatchingError(exeContext, returnType, fieldNodes, info, pa
     if (isPromise(completed)) {
       // Note: we don't rely on a `catch` method, but we do expect "thenable"
       // to take a second callback for the error case.
-      return completed.then(undefined, function (error) {
-        return handleFieldError(error, fieldNodes, path, returnType, exeContext);
+      return completed.then(undefined, function (rawError) {
+        var error = locatedError(rawError, fieldNodes, pathToArray(path));
+        return handleFieldError(error, returnType, exeContext);
       });
     }
 
     return completed;
-  } catch (error) {
-    return handleFieldError(error, fieldNodes, path, returnType, exeContext);
+  } catch (rawError) {
+    var error = locatedError(rawError, fieldNodes, pathToArray(path));
+    return handleFieldError(error, returnType, exeContext);
   }
 }
+/**
+ * @internal
+ */
+
+
+export function buildResolveInfo(exeContext, fieldDef, fieldNodes, parentType, path) {
+  // The resolve function's optional fourth argument is a collection of
+  // information about the current execution state.
+  return {
+    fieldName: fieldDef.name,
+    fieldNodes: fieldNodes,
+    returnType: fieldDef.type,
+    parentType: parentType,
+    path: path,
+    schema: exeContext.schema,
+    fragments: exeContext.fragments,
+    rootValue: exeContext.rootValue,
+    operation: exeContext.operation,
+    variableValues: exeContext.variableValues
+  };
+}
 
-function handleFieldError(rawError, fieldNodes, path, returnType, exeContext) {
-  var error = locatedError(asErrorInstance(rawError), fieldNodes, pathToArray(path)); // If the field type is non-nullable, then it is resolved without any
+function handleFieldError(error, returnType, exeContext) {
+  // If the field type is non-nullable, then it is resolved without any
   // protection from errors, however it still properly locates the error.
-
   if (isNonNullType(returnType)) {
     throw error;
   } // Otherwise, error protection is applied, logging the error and resolving
@@ -619,26 +587,47 @@ function completeValue(exeContext, returnType, fieldNodes, info, path, result) {
 
 
 function completeListValue(exeContext, returnType, fieldNodes, info, path, result) {
-  if (!isCollection(result)) {
-    throw new GraphQLError("Expected Iterable, but did not find one for field \"".concat(info.parentType.name, ".").concat(info.fieldName, "\"."));
-  } // This is specified as a simple map, however we're optimizing the path
+  // This is specified as a simple map, however we're optimizing the path
   // where the list contains no Promises by avoiding creating another Promise.
-
-
   var itemType = returnType.ofType;
   var containsPromise = false;
-  var completedResults = arrayFrom(result, function (item, index) {
+  var completedResults = safeArrayFrom(result, function (item, index) {
     // No need to modify the info object containing the path,
     // since from here on it is not ever accessed by resolver functions.
-    var fieldPath = addPath(path, index, undefined);
-    var completedItem = completeValueCatchingError(exeContext, itemType, fieldNodes, info, fieldPath, item);
+    var itemPath = addPath(path, index, undefined);
 
-    if (!containsPromise && isPromise(completedItem)) {
-      containsPromise = true;
-    }
+    try {
+      var completedItem;
+
+      if (isPromise(item)) {
+        completedItem = item.then(function (resolved) {
+          return completeValue(exeContext, itemType, fieldNodes, info, itemPath, resolved);
+        });
+      } else {
+        completedItem = completeValue(exeContext, itemType, fieldNodes, info, itemPath, item);
+      }
 
-    return completedItem;
+      if (isPromise(completedItem)) {
+        containsPromise = true; // Note: we don't rely on a `catch` method, but we do expect "thenable"
+        // to take a second callback for the error case.
+
+        return completedItem.then(undefined, function (rawError) {
+          var error = locatedError(rawError, fieldNodes, pathToArray(itemPath));
+          return handleFieldError(error, itemType, exeContext);
+        });
+      }
+
+      return completedItem;
+    } catch (rawError) {
+      var error = locatedError(rawError, fieldNodes, pathToArray(itemPath));
+      return handleFieldError(error, itemType, exeContext);
+    }
   });
+
+  if (completedResults == null) {
+    throw new GraphQLError("Expected Iterable, but did not find one for field \"".concat(info.parentType.name, ".").concat(info.fieldName, "\"."));
+  }
+
   return containsPromise ? Promise.all(completedResults) : completedResults;
 }
 /**
@@ -679,10 +668,25 @@ function completeAbstractValue(exeContext, returnType, fieldNodes, info, path, r
 }
 
 function ensureValidRuntimeType(runtimeTypeOrName, exeContext, returnType, fieldNodes, info, result) {
-  var runtimeType = typeof runtimeTypeOrName === 'string' ? exeContext.schema.getType(runtimeTypeOrName) : runtimeTypeOrName;
+  if (runtimeTypeOrName == null) {
+    throw new GraphQLError("Abstract type \"".concat(returnType.name, "\" must resolve to an Object type at runtime for field \"").concat(info.parentType.name, ".").concat(info.fieldName, "\". Either the \"").concat(returnType.name, "\" type should provide a \"resolveType\" function or each possible type should provide an \"isTypeOf\" function."), fieldNodes);
+  } // FIXME: temporary workaround until support for passing object types would be removed in v16.0.0
+
+
+  var runtimeTypeName = isNamedType(runtimeTypeOrName) ? runtimeTypeOrName.name : runtimeTypeOrName;
+
+  if (typeof runtimeTypeName !== 'string') {
+    throw new GraphQLError("Abstract type \"".concat(returnType.name, "\" must resolve to an Object type at runtime for field \"").concat(info.parentType.name, ".").concat(info.fieldName, "\" with ") + "value ".concat(inspect(result), ", received \"").concat(inspect(runtimeTypeOrName), "\"."));
+  }
+
+  var runtimeType = exeContext.schema.getType(runtimeTypeName);
+
+  if (runtimeType == null) {
+    throw new GraphQLError("Abstract type \"".concat(returnType.name, "\" was resolve to a type \"").concat(runtimeTypeName, "\" that does not exist inside schema."), fieldNodes);
+  }
 
   if (!isObjectType(runtimeType)) {
-    throw new GraphQLError("Abstract type \"".concat(returnType.name, "\" must resolve to an Object type at runtime for field \"").concat(info.parentType.name, ".").concat(info.fieldName, "\" with ") + "value ".concat(inspect(result), ", received \"").concat(inspect(runtimeType), "\". ") + "Either the \"".concat(returnType.name, "\" type should provide a \"resolveType\" function or each possible type should provide an \"isTypeOf\" function."), fieldNodes);
+    throw new GraphQLError("Abstract type \"".concat(returnType.name, "\" was resolve to a non-object type \"").concat(runtimeTypeName, "\"."), fieldNodes);
   }
 
   if (!exeContext.schema.isSubType(returnType, runtimeType)) {
@@ -784,7 +788,7 @@ export var defaultTypeResolver = function defaultTypeResolver(value, contextValu
       if (isPromise(isTypeOfResult)) {
         promisedIsTypeOfResults[i] = isTypeOfResult;
       } else if (isTypeOfResult) {
-        return type;
+        return type.name;
       }
     }
   }
@@ -793,7 +797,7 @@ export var defaultTypeResolver = function defaultTypeResolver(value, contextValu
     return Promise.all(promisedIsTypeOfResults).then(function (isTypeOfResults) {
       for (var _i9 = 0; _i9 < isTypeOfResults.length; _i9++) {
         if (isTypeOfResults[_i9]) {
-          return possibleTypes[_i9];
+          return possibleTypes[_i9].name;
         }
       }
     });
@@ -820,12 +824,12 @@ export var defaultFieldResolver = function defaultFieldResolver(source, args, co
 };
 /**
  * This method looks up the field on the given type definition.
- * It has special casing for the two introspection fields, __schema
- * and __typename. __typename is special because it can always be
- * queried as a field, even in situations where no other fields
- * are allowed, like on a Union. __schema could get automatically
- * added to the query type, but that would require mutating type
- * definitions, which would cause issues.
+ * It has special casing for the three introspection fields,
+ * __schema, __type and __typename. __typename is special because
+ * it can always be queried as a field, even in situations where no
+ * other fields are allowed, like on a Union. __schema and __type
+ * could get automatically added to the query type, but that would
+ * require mutating type definitions, which would cause issues.
  *
  * @internal
  */