@graphitation/supermassive 3.0.0-alpha.1 → 3.0.0-alpha.3

package/lib/executeWithoutSchema.mjs

@@ -40,17 +40,11 @@ var __async = (__this, __arguments, generator) => {
 
 // src/executeWithoutSchema.ts
 import {
-  GraphQLEnumType,
   GraphQLError,
-  GraphQLInputObjectType,
-  GraphQLScalarType,
-  isLeafType,
   Kind,
-  locatedError
-} from "graphql";
-import {
+  locatedError,
   OperationTypeNode
-} from "./supermassive-ast/index.mjs";
+} from "graphql";
 import {
   collectFields,
   collectSubfields as _collectSubfields
@@ -64,33 +58,32 @@ import { isPromise } from "./jsutils/isPromise.mjs";
 import { addPath, pathToArray } from "./jsutils/Path.mjs";
 import { promiseForObject } from "./jsutils/promiseForObject.mjs";
 import { promiseReduce } from "./jsutils/promiseReduce.mjs";
-import { isUnionResolverType, isInterfaceResolverType } from "./definition.mjs";
-import { mergeResolvers } from "./utilities/mergeResolvers.mjs";
-import { typeNameFromAST } from "./utilities/typeNameFromAST.mjs";
 import {
   getArgumentValues,
   getVariableValues,
-  specifiedScalars,
   getDirectiveValues
 } from "./values.mjs";
 import { arraysAreEqual } from "./utilities/array.mjs";
 import { isAsyncIterable } from "./jsutils/isAsyncIterable.mjs";
 import { mapAsyncIterator } from "./utilities/mapAsyncIterator.mjs";
-import { GraphQLStreamDirective } from "./directives.mjs";
+import { GraphQLStreamDirective } from "./schema/directives.mjs";
 import { memoize3 } from "./jsutils/memoize3.mjs";
+import { SchemaFragment } from "./schema/fragment.mjs";
+import {
+  inspectTypeReference,
+  isListType,
+  isNonNullType,
+  typeNameFromReference,
+  unwrap
+} from "./schema/reference.mjs";
+import { getSchemaFragment } from "./utilities/getSchemaFragment.mjs";
+import { mergeSchemaDefinitions } from "./utilities/mergeDefinitions.mjs";
 var collectSubfields = memoize3(
-  (exeContext, returnTypeName, fieldGroup) => _collectSubfields(
-    exeContext.resolvers,
-    exeContext.fragments,
-    exeContext.variableValues,
-    exeContext.operation,
-    returnTypeName.name,
-    fieldGroup
-  )
+  (exeContext, returnTypeName, fieldGroup) => _collectSubfields(exeContext, returnTypeName.name, fieldGroup)
 );
 function executeWithoutSchema(args) {
   const exeContext = buildExecutionContext(args);
-  if (!("resolvers" in exeContext)) {
+  if (!("schemaTypes" in exeContext)) {
     return { errors: exeContext };
   } else {
     return executeOperation(exeContext);
@@ -107,7 +100,7 @@ function buildExecutionContext(args) {
   var _a, _b;
   const {
     resolvers,
-    schemaResolvers,
+    schemaFragment: explicitSchemaFragment,
     document,
     rootValue,
     contextValue,
@@ -120,7 +113,6 @@ function buildExecutionContext(args) {
     fieldExecutionHooks
   } = args;
   assertValidExecutionArguments(document, variableValues);
-  const combinedResolvers = schemaResolvers ? mergeResolvers(resolvers, schemaResolvers) : resolvers;
   let operation;
   const fragments = /* @__PURE__ */ Object.create(null);
   for (const definition of document.definitions) {
@@ -150,9 +142,24 @@ function buildExecutionContext(args) {
     }
     return [new GraphQLError("Must provide an operation.")];
   }
+  let schemaFragment = explicitSchemaFragment;
+  if (!schemaFragment) {
+    schemaFragment = getSchemaFragment(operation);
+    if (schemaFragment && !schemaFragment.__merged) {
+      mergeSchemaDefinitions(
+        schemaFragment,
+        Object.values(fragments).map((fragmentDef) => getSchemaFragment(fragmentDef)).filter((f) => Boolean(f))
+      );
+      schemaFragment.__merged = true;
+    }
+  }
+  if (!schemaFragment) {
+    return [new GraphQLError("Must provide schema fragment.")];
+  }
   const variableDefinitions = (_b = operation.variableDefinitions) != null ? _b : [];
+  const schemaTypes = new SchemaFragment(schemaFragment, resolvers);
   const coercedVariableValues = getVariableValues(
-    combinedResolvers,
+    schemaTypes,
     variableDefinitions,
     variableValues != null ? variableValues : {},
     { maxErrors: 50 }
@@ -161,7 +168,7 @@ function buildExecutionContext(args) {
     return coercedVariableValues.errors;
   }
   return {
-    resolvers: combinedResolvers,
+    schemaTypes,
     fragments,
     rootValue,
     contextValue: buildContextValue ? buildContextValue(contextValue) : contextValue,
@@ -185,15 +192,9 @@ function buildPerEventExecutionContext(exeContext, payload) {
   });
 }
 function executeOperation(exeContext) {
-  const { operation, rootValue, resolvers, fragments, variableValues } = exeContext;
+  const { operation, rootValue } = exeContext;
   const rootTypeName = getOperationRootTypeName(operation);
-  const { groupedFieldSet, patches } = collectFields(
-    resolvers,
-    fragments,
-    variableValues,
-    rootTypeName,
-    operation
-  );
+  const { groupedFieldSet, patches } = collectFields(exeContext, rootTypeName);
   const path = void 0;
   let result;
   switch (operation.operation) {
@@ -323,52 +324,34 @@ function executeFields(exeContext, parentTypeName, sourceValue, path, groupedFie
   return promiseForObject(results);
 }
 function executeField(exeContext, parentTypeName, source, fieldGroup, path, incrementalDataRecord) {
+  var _a;
+  const schemaTypes = exeContext.schemaTypes;
   const fieldName = fieldGroup[0].name.value;
-  let resolveFn;
-  let returnTypeName;
-  let returnTypeNode;
-  if (fieldName === "__typename" && !resolveFn) {
-    resolveFn = () => parentTypeName;
-    returnTypeName = "String";
-    returnTypeNode = {
-      kind: Kind.NAMED_TYPE,
-      name: {
-        kind: Kind.NAME,
-        value: "String"
-      }
-    };
-  } else {
-    returnTypeNode = fieldGroup[0].__type;
-    returnTypeName = typeNameFromAST(returnTypeNode);
-    const typeResolvers = exeContext.resolvers[parentTypeName];
-    resolveFn = typeResolvers == null ? void 0 : typeResolvers[fieldName];
-    if (typeof resolveFn !== "function" && resolveFn != null) {
-      resolveFn = resolveFn.resolve;
-    }
-  }
-  const isDefaultResolverUsed = !resolveFn;
-  if (!resolveFn) {
-    resolveFn = exeContext.fieldResolver;
+  const fieldDef = schemaTypes.getField(parentTypeName, fieldName);
+  if (fieldDef === void 0) {
+    return;
   }
+  const returnTypeRef = schemaTypes.getTypeReference(fieldDef);
+  const resolveFn = (_a = schemaTypes.getFieldResolver(parentTypeName, fieldName)) != null ? _a : exeContext.fieldResolver;
   const info = buildResolveInfo(
     exeContext,
     fieldName,
     fieldGroup,
     parentTypeName,
-    returnTypeName,
-    returnTypeNode,
+    typeNameFromReference(returnTypeRef),
     path
   );
   return resolveAndCompleteField(
     exeContext,
-    returnTypeNode,
+    parentTypeName,
+    returnTypeRef,
+    fieldDef,
     fieldGroup,
     info,
     path,
     resolveFn,
     source,
-    incrementalDataRecord,
-    isDefaultResolverUsed
+    incrementalDataRecord
   );
 }
 function createSourceEventStream(exeContext) {
@@ -383,71 +366,43 @@ function createSourceEventStream(exeContext) {
   }
 }
 function executeSubscriptionImpl(exeContext) {
-  const { resolvers, fragments, operation, variableValues, rootValue } = exeContext;
-  const typeName = getOperationRootTypeName(operation);
-  const { groupedFieldSet } = collectFields(
-    resolvers,
-    fragments,
-    variableValues,
-    typeName,
-    operation
-  );
+  var _a;
+  const { operation, rootValue, schemaTypes } = exeContext;
+  const rootTypeName = getOperationRootTypeName(operation);
+  const { groupedFieldSet } = collectFields(exeContext, rootTypeName);
   const firstRootField = groupedFieldSet.entries().next().value;
   const [responseName, fieldGroup] = firstRootField;
   const fieldName = fieldGroup[0].name.value;
-  let resolveFn;
-  let returnTypeName;
-  let returnTypeNode;
-  if (fieldName === "__typename" && !resolveFn) {
-    resolveFn = () => typeName;
-    returnTypeName = "String";
-    returnTypeNode = {
-      kind: Kind.NAMED_TYPE,
-      name: {
-        kind: Kind.NAME,
-        value: "String"
-      }
-    };
-  } else {
-    returnTypeNode = fieldGroup[0].__type;
-    returnTypeName = typeNameFromAST(returnTypeNode);
-    const typeResolvers = exeContext.resolvers[typeName];
-    const fieldResolver = typeResolvers == null ? void 0 : typeResolvers[fieldName];
-    resolveFn = fieldResolver == null ? void 0 : fieldResolver.subscribe;
-  }
-  if (!resolveFn) {
-    resolveFn = exeContext.subscribeFieldResolver;
+  const fieldDef = schemaTypes.getField(rootTypeName, fieldName);
+  if (!fieldDef) {
+    throw new GraphQLError(
+      `The subscription field "${fieldName}" is not defined.`,
+      { nodes: fieldGroup }
+    );
   }
-  const path = addPath(void 0, responseName, typeName);
+  const returnTypeRef = schemaTypes.getTypeReference(fieldDef);
+  const resolveFn = (_a = schemaTypes.getSubscriptionFieldResolver(rootTypeName, fieldName)) != null ? _a : exeContext.subscribeFieldResolver;
+  const path = addPath(void 0, responseName, rootTypeName);
   const info = buildResolveInfo(
     exeContext,
     fieldName,
     fieldGroup,
-    typeName,
-    returnTypeName,
-    returnTypeNode,
+    rootTypeName,
+    typeNameFromReference(returnTypeRef),
     path
   );
   try {
-    const args = getArgumentValues(resolvers, fieldGroup[0], variableValues);
+    const args = getArgumentValues(exeContext, fieldDef, fieldGroup[0]);
     const contextValue = exeContext.contextValue;
     const result = resolveFn(rootValue, args, contextValue, info);
     if (isPromise(result)) {
       return result.then(assertEventStream).then(void 0, (error) => {
-        throw locatedError(
-          error,
-          fieldGroup,
-          pathToArray(path)
-        );
+        throw locatedError(error, fieldGroup, pathToArray(path));
       });
     }
     return assertEventStream(result);
   } catch (error) {
-    throw locatedError(
-      error,
-      fieldGroup,
-      pathToArray(path)
-    );
+    throw locatedError(error, fieldGroup, pathToArray(path));
   }
 }
 function assertEventStream(result) {
@@ -495,13 +450,12 @@ function mapResultOrEventStreamOrPromise(resultOrStreamOrPromise, exeContext, pa
     }
   }
 }
-function buildResolveInfo(exeContext, fieldName, fieldGroup, parentTypeName, returnTypeName, returnTypeNode, path) {
+function buildResolveInfo(exeContext, fieldName, fieldGroup, parentTypeName, returnTypeName, path) {
   return {
     fieldName,
     fieldGroup,
     returnTypeName,
     parentTypeName,
-    returnTypeNode,
     path,
     fragments: exeContext.fragments,
     rootValue: exeContext.rootValue,
@@ -509,27 +463,20 @@ function buildResolveInfo(exeContext, fieldName, fieldGroup, parentTypeName, ret
     variableValues: exeContext.variableValues
   };
 }
-function handleFieldError(rawError, exeContext, returnTypeNode, fieldGroup, path, incrementalDataRecord) {
+function handleFieldError(rawError, exeContext, returnTypeRef, fieldGroup, path, incrementalDataRecord) {
   var _a;
-  const error = locatedError(
-    rawError,
-    fieldGroup,
-    pathToArray(path)
-  );
-  if (returnTypeNode.kind === Kind.NON_NULL_TYPE) {
+  const error = locatedError(rawError, fieldGroup, pathToArray(path));
+  if (isNonNullType(returnTypeRef)) {
     throw error;
   }
   const errors = (_a = incrementalDataRecord == null ? void 0 : incrementalDataRecord.errors) != null ? _a : exeContext.errors;
   errors.push(error);
 }
-function resolveAndCompleteField(exeContext, returnTypeNode, fieldGroup, info, path, resolveFn, source, incrementalDataRecord, isDefaultResolverUsed) {
+function resolveAndCompleteField(exeContext, parentTypeName, returnTypeRef, fieldDefinition, fieldGroup, info, path, resolveFn, source, incrementalDataRecord) {
+  const isDefaultResolverUsed = resolveFn === exeContext.fieldResolver;
   const hooks = exeContext.fieldExecutionHooks;
   try {
-    const args = getArgumentValues(
-      exeContext.resolvers,
-      fieldGroup[0],
-      exeContext.variableValues
-    );
+    const args = getArgumentValues(exeContext, fieldDefinition, fieldGroup[0]);
     const contextValue = exeContext.contextValue;
     if (!isDefaultResolverUsed && (hooks == null ? void 0 : hooks.beforeFieldResolve)) {
       invokeBeforeFieldResolveHook(info, exeContext);
@@ -544,7 +491,7 @@ function resolveAndCompleteField(exeContext, returnTypeNode, fieldGroup, info, p
           }
           return completeValue(
             exeContext,
-            returnTypeNode,
+            returnTypeRef,
             fieldGroup,
             info,
             path,
@@ -565,7 +512,7 @@ function resolveAndCompleteField(exeContext, returnTypeNode, fieldGroup, info, p
       }
       completed = completeValue(
         exeContext,
-        returnTypeNode,
+        returnTypeRef,
         fieldGroup,
         info,
         path,
@@ -582,18 +529,14 @@ function resolveAndCompleteField(exeContext, returnTypeNode, fieldGroup, info, p
           return resolved;
         },
         (rawError) => {
-          const error = locatedError(
-            rawError,
-            fieldGroup,
-            pathToArray(path)
-          );
+          const error = locatedError(rawError, fieldGroup, pathToArray(path));
           if (!isDefaultResolverUsed && (hooks == null ? void 0 : hooks.afterFieldComplete)) {
             invokeAfterFieldCompleteHook(info, exeContext, void 0, error);
           }
           handleFieldError(
             rawError,
             exeContext,
-            returnTypeNode,
+            returnTypeRef,
             fieldGroup,
             path,
             incrementalDataRecord
@@ -608,11 +551,7 @@ function resolveAndCompleteField(exeContext, returnTypeNode, fieldGroup, info, p
     return completed;
   } catch (rawError) {
     const pathArray = pathToArray(path);
-    const error = locatedError(
-      rawError,
-      fieldGroup,
-      pathArray
-    );
+    const error = locatedError(rawError, fieldGroup, pathArray);
     if (!isDefaultResolverUsed && (hooks == null ? void 0 : hooks.afterFieldResolve) && error.path && arraysAreEqual(pathArray, error.path)) {
       invokeAfterFieldResolveHook(info, exeContext, void 0, error);
     }
@@ -622,7 +561,7 @@ function resolveAndCompleteField(exeContext, returnTypeNode, fieldGroup, info, p
     handleFieldError(
       rawError,
       exeContext,
-      returnTypeNode,
+      returnTypeRef,
       fieldGroup,
       path,
       incrementalDataRecord
@@ -630,14 +569,14 @@ function resolveAndCompleteField(exeContext, returnTypeNode, fieldGroup, info, p
     return null;
   }
 }
-function completeValue(exeContext, returnTypeNode, fieldGroup, info, path, result, incrementalDataRecord) {
+function completeValue(exeContext, returnTypeRef, fieldGroup, info, path, result, incrementalDataRecord) {
   if (result instanceof Error) {
     throw result;
   }
-  if (returnTypeNode.kind === Kind.NON_NULL_TYPE) {
+  if (isNonNullType(returnTypeRef)) {
     const completed = completeValue(
       exeContext,
-      returnTypeNode.type,
+      unwrap(returnTypeRef),
       fieldGroup,
       info,
       path,
@@ -654,10 +593,10 @@ function completeValue(exeContext, returnTypeNode, fieldGroup, info, path, resul
   if (result == null) {
     return null;
   }
-  if (returnTypeNode.kind === Kind.LIST_TYPE) {
+  if (isListType(returnTypeRef)) {
     return completeListValue(
       exeContext,
-      returnTypeNode,
+      returnTypeRef,
       fieldGroup,
       info,
       path,
@@ -665,20 +604,16 @@ function completeValue(exeContext, returnTypeNode, fieldGroup, info, path, resul
       incrementalDataRecord
     );
   }
-  const returnTypeName = returnTypeNode.name.value;
-  let returnType = exeContext.resolvers[returnTypeName];
-  if (!returnType) {
-    returnType = specifiedScalars[returnTypeName];
-  }
-  if (isLeafType(returnType)) {
-    return completeLeafValue(returnType, result);
+  const schemaTypes = exeContext.schemaTypes;
+  const returnTypeName = typeNameFromReference(returnTypeRef);
+  const leafType = schemaTypes.getLeafTypeResolver(returnTypeRef);
+  if (leafType) {
+    return completeLeafValue(leafType, result);
   }
-  if (returnType instanceof GraphQLInputObjectType) {
-  }
-  if (isUnionResolverType(returnType) || isInterfaceResolverType(returnType)) {
+  if (schemaTypes.isAbstractType(returnTypeRef)) {
     return completeAbstractValue(
       exeContext,
-      returnType,
+      returnTypeName,
       fieldGroup,
       info,
       path,
@@ -686,7 +621,7 @@ function completeValue(exeContext, returnTypeNode, fieldGroup, info, path, resul
       incrementalDataRecord
     );
   }
-  if (typeof returnType === "object") {
+  if (schemaTypes.isObjectType(returnTypeRef)) {
     return completeObjectValue(
       exeContext,
       returnTypeName,
@@ -698,16 +633,16 @@ function completeValue(exeContext, returnTypeNode, fieldGroup, info, path, resul
   }
   invariant(
     false,
-    "Cannot complete value of unexpected output type: " + inspect(returnType)
+    "Cannot complete value of unexpected output type: " + inspectTypeReference(returnTypeRef)
   );
 }
-function completePromisedValue(exeContext, returnTypeNode, fieldGroup, info, path, result, incrementalDataRecord) {
+function completePromisedValue(exeContext, returnTypeRef, fieldGroup, info, path, result, incrementalDataRecord) {
   return __async(this, null, function* () {
     try {
       const resolved = yield result;
       let completed = completeValue(
         exeContext,
-        returnTypeNode,
+        returnTypeRef,
         fieldGroup,
         info,
         path,
@@ -722,7 +657,7 @@ function completePromisedValue(exeContext, returnTypeNode, fieldGroup, info, pat
       handleFieldError(
         rawError,
         exeContext,
-        returnTypeNode,
+        returnTypeRef,
         fieldGroup,
         path,
         incrementalDataRecord
@@ -732,13 +667,13 @@ function completePromisedValue(exeContext, returnTypeNode, fieldGroup, info, pat
     }
   });
 }
-function completeListValue(exeContext, returnTypeNode, fieldGroup, info, path, result, incrementalDataRecord) {
-  const itemType = returnTypeNode.type;
+function completeListValue(exeContext, returnTypeRef, fieldGroup, info, path, result, incrementalDataRecord) {
+  const itemTypeRef = unwrap(returnTypeRef);
   if (isAsyncIterable(result)) {
     const asyncIterator = result[Symbol.asyncIterator]();
     return completeAsyncIteratorValue(
       exeContext,
-      itemType,
+      itemTypeRef,
       fieldGroup,
       info,
       path,
@@ -766,7 +701,7 @@ function completeListValue(exeContext, returnTypeNode, fieldGroup, info, path, r
         exeContext,
         fieldGroup,
         info,
-        itemType,
+        itemTypeRef,
         stream.label,
         previousIncrementalDataRecord
       );
@@ -777,7 +712,7 @@ function completeListValue(exeContext, returnTypeNode, fieldGroup, info, path, r
       item,
       completedResults,
       exeContext,
-      itemType,
+      itemTypeRef,
       fieldGroup,
       info,
       itemPath,
@@ -789,12 +724,12 @@ function completeListValue(exeContext, returnTypeNode, fieldGroup, info, path, r
   }
   return containsPromise ? Promise.all(completedResults) : completedResults;
 }
-function completeListItemValue(item, completedResults, exeContext, itemTypeNode, fieldGroup, info, itemPath, incrementalDataRecord) {
+function completeListItemValue(item, completedResults, exeContext, itemTypeRef, fieldGroup, info, itemPath, incrementalDataRecord) {
   if (isPromise(item)) {
     completedResults.push(
       completePromisedValue(
         exeContext,
-        itemTypeNode,
+        itemTypeRef,
         fieldGroup,
         info,
         itemPath,
@@ -807,7 +742,7 @@ function completeListItemValue(item, completedResults, exeContext, itemTypeNode,
   try {
     const completedItem = completeValue(
       exeContext,
-      itemTypeNode,
+      itemTypeRef,
       fieldGroup,
       info,
       itemPath,
@@ -820,7 +755,7 @@ function completeListItemValue(item, completedResults, exeContext, itemTypeNode,
           handleFieldError(
             rawError,
             exeContext,
-            itemTypeNode,
+            itemTypeRef,
             fieldGroup,
             itemPath,
             incrementalDataRecord
@@ -836,7 +771,7 @@ function completeListItemValue(item, completedResults, exeContext, itemTypeNode,
     handleFieldError(
       rawError,
       exeContext,
-      itemTypeNode,
+      itemTypeRef,
       fieldGroup,
       itemPath,
       incrementalDataRecord
@@ -851,10 +786,9 @@ function getStreamValues(exeContext, fieldGroup, path) {
     return;
   }
   const stream = getDirectiveValues(
+    exeContext,
     GraphQLStreamDirective,
-    fieldGroup[0],
-    exeContext.resolvers,
-    exeContext.variableValues
+    fieldGroup[0]
   );
   if (!stream) {
     return;
@@ -879,7 +813,7 @@ function getStreamValues(exeContext, fieldGroup, path) {
     label: typeof stream.label === "string" ? stream.label : void 0
   };
 }
-function completeAsyncIteratorValue(exeContext, itemType, fieldGroup, info, path, asyncIterator, incrementalDataRecord) {
+function completeAsyncIteratorValue(exeContext, itemTypeRef, fieldGroup, info, path, asyncIterator, incrementalDataRecord) {
   return __async(this, null, function* () {
     const stream = getStreamValues(exeContext, fieldGroup, path);
     let containsPromise = false;
@@ -893,7 +827,7 @@ function completeAsyncIteratorValue(exeContext, itemType, fieldGroup, info, path
           exeContext,
           fieldGroup,
           info,
-          itemType,
+          itemTypeRef,
           path,
           stream.label,
           incrementalDataRecord
@@ -908,17 +842,13 @@ function completeAsyncIteratorValue(exeContext, itemType, fieldGroup, info, path
           break;
         }
       } catch (rawError) {
-        throw locatedError(
-          rawError,
-          fieldGroup,
-          pathToArray(path)
-        );
+        throw locatedError(rawError, fieldGroup, pathToArray(path));
       }
       if (completeListItemValue(
         iteration.value,
         completedResults,
         exeContext,
-        itemType,
+        itemTypeRef,
         fieldGroup,
         info,
         itemPath,
@@ -940,16 +870,23 @@ function completeLeafValue(returnType, result) {
   }
   return serializedResult;
 }
-function completeAbstractValue(exeContext, returnType, fieldGroup, info, path, result, incrementalDataRecord) {
+function completeAbstractValue(exeContext, returnTypeName, fieldGroup, info, path, result, incrementalDataRecord) {
   var _a;
-  const resolveTypeFn = (_a = returnType.__resolveType) != null ? _a : exeContext.typeResolver;
+  const resolveTypeFn = (_a = exeContext.schemaTypes.getAbstractTypeResolver(returnTypeName)) != null ? _a : exeContext.typeResolver;
   const contextValue = exeContext.contextValue;
   const runtimeTypeName = resolveTypeFn(result, contextValue, info);
   if (isPromise(runtimeTypeName)) {
     return runtimeTypeName.then(
       (resolvedRuntimeTypeName) => completeObjectValue(
         exeContext,
-        ensureValidRuntimeType(resolvedRuntimeTypeName, exeContext),
+        ensureValidRuntimeType(
+          resolvedRuntimeTypeName,
+          exeContext,
+          returnTypeName,
+          fieldGroup,
+          info,
+          result
+        ),
         fieldGroup,
         path,
         result,
@@ -959,48 +896,63 @@ function completeAbstractValue(exeContext, returnType, fieldGroup, info, path, r
   }
   return completeObjectValue(
     exeContext,
-    ensureValidRuntimeType(runtimeTypeName, exeContext),
+    ensureValidRuntimeType(
+      runtimeTypeName,
+      exeContext,
+      returnTypeName,
+      fieldGroup,
+      info,
+      result
+    ),
     fieldGroup,
     path,
     result,
     incrementalDataRecord
   );
 }
-function ensureValidRuntimeType(runtimeTypeName, exeContext) {
-  if (typeof runtimeTypeName !== "string") {
+function ensureValidRuntimeType(runtimeTypeName, exeContext, returnTypeName, fieldGroup, info, result) {
+  if (runtimeTypeName == null) {
     throw new GraphQLError(
-      `Could not determine runtime type for abstract type ${runtimeTypeName}`
+      `Abstract type "${returnTypeName}" must resolve to an Object type at runtime for field "${info.parentTypeName}.${info.fieldName}". Either the "${returnTypeName}" should provide a "__resolveType" resolver function or "${info.parentTypeName}.${info.fieldName}" should be an object with "__typename" property.`,
+      { nodes: fieldGroup }
     );
   }
-  const runtimeType = exeContext.resolvers[runtimeTypeName];
-  if (!runtimeType) {
-    throw new GraphQLError(
-      `Type "${runtimeTypeName}" does not exist inside the schema.`
-    );
-  } else if (runtimeType instanceof GraphQLScalarType || runtimeType instanceof GraphQLEnumType || runtimeType instanceof GraphQLInputObjectType || runtimeType.__resolveType) {
+  if (typeof runtimeTypeName !== "string") {
     throw new GraphQLError(
-      `Given runtime object "${getRuntimeTypeInstanceName(
-        runtimeType
-      )}" type is not a possible type for "${runtimeTypeName}".`
+      `Abstract type "${returnTypeName}" must resolve to an Object type at runtime for field "${info.returnTypeName}.${info.fieldName}" with value ${inspect(result)}, received "${inspect(runtimeTypeName)}".`
     );
-  } else {
-    return runtimeTypeName;
   }
-}
-function getRuntimeTypeInstanceName(runtimeType) {
-  if (runtimeType instanceof GraphQLScalarType) {
-    return "GraphQLScalarType";
-  } else if (runtimeType instanceof GraphQLEnumType) {
-    return "GraphQLEnumType";
-  } else if (runtimeType instanceof GraphQLInputObjectType) {
-    return "GraphQLInputObjectType";
-  } else if ("__types" in runtimeType) {
-    return "GraphQLUnionType";
-  } else if ("__implementedBy" in runtimeType) {
-    return "GraphQLInterfaceType";
+  const schemaTypes = exeContext.schemaTypes;
+  const iface = schemaTypes.getInterfaceType(returnTypeName);
+  if (iface) {
+    if (schemaTypes.isDefined(runtimeTypeName) && !schemaTypes.isObjectType(runtimeTypeName)) {
+      throw new GraphQLError(
+        `Abstract type "${returnTypeName}" was resolved to a non-object type "${runtimeTypeName}".`,
+        { nodes: fieldGroup }
+      );
+    }
+    schemaTypes.addInterfaceImplementation(returnTypeName, runtimeTypeName);
   } else {
-    return "Unknown";
+    if (!schemaTypes.isDefined(runtimeTypeName)) {
+      throw new GraphQLError(
+        `Abstract type "${returnTypeName}" was resolved to a type "${runtimeTypeName}" that does not exist inside the schema.`,
+        { nodes: fieldGroup }
+      );
+    }
+    if (!schemaTypes.isObjectType(runtimeTypeName)) {
+      throw new GraphQLError(
+        `Abstract type "${returnTypeName}" was resolved to a non-object type "${runtimeTypeName}".`,
+        { nodes: fieldGroup }
+      );
+    }
+    if (!exeContext.schemaTypes.isSubType(returnTypeName, runtimeTypeName)) {
+      throw new GraphQLError(
+        `Runtime Object type "${runtimeTypeName}" is not a possible type for "${returnTypeName}".`,
+        { nodes: fieldGroup }
+      );
+    }
   }
+  return runtimeTypeName;
 }
 function completeObjectValue(exeContext, returnTypeName, fieldGroup, path, result, incrementalDataRecord) {
   return collectAndExecuteSubfields(
@@ -1182,7 +1134,7 @@ function executeDeferredFragment(exeContext, parentTypeName, sourceValue, fields
   }
   incrementalDataRecord.addData(promiseOrData);
 }
-function executeStreamField(path, itemPath, item, exeContext, fieldGroup, info, itemTypeNode, label, parentContext) {
+function executeStreamField(path, itemPath, item, exeContext, fieldGroup, info, itemTypeRef, label, parentContext) {
   const incrementalDataRecord = new StreamItemsRecord({
     label,
     path: itemPath,
@@ -1192,7 +1144,7 @@ function executeStreamField(path, itemPath, item, exeContext, fieldGroup, info,
   if (isPromise(item)) {
     const completedItems = completePromisedValue(
       exeContext,
-      itemTypeNode,
+      itemTypeRef,
       fieldGroup,
       info,
       itemPath,
@@ -1214,7 +1166,7 @@ function executeStreamField(path, itemPath, item, exeContext, fieldGroup, info,
     try {
       completedItem = completeValue(
         exeContext,
-        itemTypeNode,
+        itemTypeRef,
         fieldGroup,
         info,
         itemPath,
@@ -1225,7 +1177,7 @@ function executeStreamField(path, itemPath, item, exeContext, fieldGroup, info,
       handleFieldError(
         rawError,
         exeContext,
-        itemTypeNode,
+        itemTypeRef,
         fieldGroup,
         itemPath,
         incrementalDataRecord
@@ -1244,7 +1196,7 @@ function executeStreamField(path, itemPath, item, exeContext, fieldGroup, info,
       handleFieldError(
         rawError,
         exeContext,
-        itemTypeNode,
+        itemTypeRef,
         fieldGroup,
         itemPath,
         incrementalDataRecord
@@ -1265,7 +1217,7 @@ function executeStreamField(path, itemPath, item, exeContext, fieldGroup, info,
   incrementalDataRecord.addItems([completedItem]);
   return incrementalDataRecord;
 }
-function executeStreamAsyncIteratorItem(asyncIterator, exeContext, fieldGroup, info, itemTypeNode, incrementalDataRecord, path, itemPath) {
+function executeStreamAsyncIteratorItem(asyncIterator, exeContext, fieldGroup, info, itemTypeRef, incrementalDataRecord, path, itemPath) {
   return __async(this, null, function* () {
     let item;
     try {
@@ -1276,17 +1228,13 @@ function executeStreamAsyncIteratorItem(asyncIterator, exeContext, fieldGroup, i
       }
       item = value;
     } catch (rawError) {
-      throw locatedError(
-        rawError,
-        fieldGroup,
-        pathToArray(path)
-      );
+      throw locatedError(rawError, fieldGroup, pathToArray(path));
     }
     let completedItem;
     try {
       completedItem = completeValue(
         exeContext,
-        itemTypeNode,
+        itemTypeRef,
         fieldGroup,
         info,
         itemPath,
@@ -1298,7 +1246,7 @@ function executeStreamAsyncIteratorItem(asyncIterator, exeContext, fieldGroup, i
           handleFieldError(
             rawError,
             exeContext,
-            itemTypeNode,
+            itemTypeRef,
             fieldGroup,
             itemPath,
             incrementalDataRecord
@@ -1312,7 +1260,7 @@ function executeStreamAsyncIteratorItem(asyncIterator, exeContext, fieldGroup, i
       handleFieldError(
         rawError,
         exeContext,
-        itemTypeNode,
+        itemTypeRef,
         fieldGroup,
         itemPath,
         incrementalDataRecord
@@ -1322,7 +1270,7 @@ function executeStreamAsyncIteratorItem(asyncIterator, exeContext, fieldGroup, i
     }
   });
 }
-function executeStreamAsyncIterator(initialIndex, asyncIterator, exeContext, fieldGroup, info, itemTypeNode, path, label, parentContext) {
+function executeStreamAsyncIterator(initialIndex, asyncIterator, exeContext, fieldGroup, info, itemTypeRef, path, label, parentContext) {
   return __async(this, null, function* () {
     let index = initialIndex;
     let previousIncrementalDataRecord = parentContext != null ? parentContext : void 0;
@@ -1342,7 +1290,7 @@ function executeStreamAsyncIterator(initialIndex, asyncIterator, exeContext, fie
           exeContext,
           fieldGroup,
           info,
-          itemTypeNode,
+          itemTypeRef,
           incrementalDataRecord,
           path,
           itemPath