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

package/lib/executeWithoutSchema.mjs

@@ -40,17 +40,10 @@ var __async = (__this, __arguments, generator) => {
 
 // src/executeWithoutSchema.ts
 import {
-  GraphQLEnumType,
   GraphQLError,
-  GraphQLInputObjectType,
-  GraphQLScalarType,
-  isLeafType,
   Kind,
   locatedError
 } from "graphql";
-import {
-  OperationTypeNode
-} from "./supermassive-ast/index.mjs";
 import {
   collectFields,
   collectSubfields as _collectSubfields
@@ -64,33 +57,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 {
+  PartialSchema
+} from "./schema/fragment.mjs";
+import {
+  inspectTypeReference,
+  isListType,
+  isNonNullType,
+  typeNameFromReference,
+  unwrap
+} from "./schema/reference.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 (!("partialSchema" in exeContext)) {
     return { errors: exeContext };
   } else {
     return executeOperation(exeContext);
@@ -106,8 +98,9 @@ function assertValidExecutionArguments(document, rawVariableValues) {
 function buildExecutionContext(args) {
   var _a, _b;
   const {
-    resolvers,
-    schemaResolvers,
+    // resolvers,
+    schemaFragment,
+    schemaFragmentLoader,
     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) {
@@ -151,8 +143,9 @@ function buildExecutionContext(args) {
     return [new GraphQLError("Must provide an operation.")];
   }
   const variableDefinitions = (_b = operation.variableDefinitions) != null ? _b : [];
+  const partialSchema = new PartialSchema(schemaFragment);
   const coercedVariableValues = getVariableValues(
-    combinedResolvers,
+    partialSchema,
     variableDefinitions,
     variableValues != null ? variableValues : {},
     { maxErrors: 50 }
@@ -161,7 +154,9 @@ function buildExecutionContext(args) {
     return coercedVariableValues.errors;
   }
   return {
-    resolvers: combinedResolvers,
+    partialSchema,
+    schemaFragment,
+    schemaFragmentLoader,
     fragments,
     rootValue,
     contextValue: buildContextValue ? buildContextValue(contextValue) : contextValue,
@@ -185,19 +180,13 @@ 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) {
-    case OperationTypeNode.QUERY:
+    case "query":
       result = executeFields(
         exeContext,
         rootTypeName,
@@ -208,7 +197,7 @@ function executeOperation(exeContext) {
       );
       result = buildResponse(exeContext, result);
       break;
-    case OperationTypeNode.MUTATION:
+    case "mutation":
       result = executeFieldsSerially(
         exeContext,
         rootTypeName,
@@ -218,7 +207,7 @@ function executeOperation(exeContext) {
       );
       result = buildResponse(exeContext, result);
       break;
-    case OperationTypeNode.SUBSCRIPTION: {
+    case "subscription": {
       const resultOrStreamOrPromise = createSourceEventStream(exeContext);
       result = mapResultOrEventStreamOrPromise(
         resultOrStreamOrPromise,
@@ -227,7 +216,13 @@ function executeOperation(exeContext) {
         path,
         groupedFieldSet
       );
+      break;
     }
+    default:
+      invariant(
+        false,
+        `Operation "${operation.operation}" is not a part of GraphQL spec`
+      );
   }
   for (const patch of patches) {
     const { label, groupedFieldSet: patchGroupedFieldSet } = patch;
@@ -324,52 +319,43 @@ function executeFields(exeContext, parentTypeName, sourceValue, path, groupedFie
 }
 function executeField(exeContext, parentTypeName, source, fieldGroup, path, incrementalDataRecord) {
   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 fieldDef = exeContext.partialSchema.getField(parentTypeName, fieldName);
+  if (fieldDef !== void 0) {
+    return resolveAndCompleteField(
+      exeContext,
+      parentTypeName,
+      fieldDef,
+      fieldGroup,
+      path,
+      source,
+      incrementalDataRecord
+    );
   }
-  const isDefaultResolverUsed = !resolveFn;
-  if (!resolveFn) {
-    resolveFn = exeContext.fieldResolver;
+  if (!exeContext.schemaFragmentLoader) {
+    return void 0;
   }
-  const info = buildResolveInfo(
-    exeContext,
-    fieldName,
-    fieldGroup,
+  return exeContext.schemaFragmentLoader(exeContext.schemaFragment, exeContext.contextValue, {
+    kind: "byField",
     parentTypeName,
-    returnTypeName,
-    returnTypeNode,
-    path
-  );
-  return resolveAndCompleteField(
-    exeContext,
-    returnTypeNode,
-    fieldGroup,
-    info,
-    path,
-    resolveFn,
-    source,
-    incrementalDataRecord,
-    isDefaultResolverUsed
-  );
+    fieldName
+  }).then(({ mergedFragment, mergedContextValue }) => {
+    exeContext.contextValue = mergedContextValue != null ? mergedContextValue : exeContext.contextValue;
+    exeContext.schemaFragment = mergedFragment;
+    exeContext.partialSchema.updateSchemaFragment(mergedFragment);
+    const fieldDef2 = exeContext.partialSchema.getField(
+      parentTypeName,
+      fieldName
+    );
+    return fieldDef2 !== void 0 ? resolveAndCompleteField(
+      exeContext,
+      parentTypeName,
+      fieldDef2,
+      fieldGroup,
+      path,
+      source,
+      incrementalDataRecord
+    ) : void 0;
+  });
 }
 function createSourceEventStream(exeContext) {
   try {
@@ -383,71 +369,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, partialSchema } = 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 = partialSchema.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 = partialSchema.getTypeReference(fieldDef);
+  const resolveFn = (_a = partialSchema.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 +453,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 +466,32 @@ 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, fieldDefinition, fieldGroup, path, source, incrementalDataRecord) {
+  var _a;
+  const fieldName = fieldGroup[0].name.value;
+  const returnTypeRef = exeContext.partialSchema.getTypeReference(fieldDefinition);
+  const resolveFn = (_a = exeContext.partialSchema.getFieldResolver(parentTypeName, fieldName)) != null ? _a : exeContext.fieldResolver;
+  const info = buildResolveInfo(
+    exeContext,
+    fieldName,
+    fieldGroup,
+    parentTypeName,
+    typeNameFromReference(returnTypeRef),
+    path
+  );
+  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 +506,7 @@ function resolveAndCompleteField(exeContext, returnTypeNode, fieldGroup, info, p
           }
           return completeValue(
             exeContext,
-            returnTypeNode,
+            returnTypeRef,
             fieldGroup,
             info,
             path,
@@ -565,7 +527,7 @@ function resolveAndCompleteField(exeContext, returnTypeNode, fieldGroup, info, p
       }
       completed = completeValue(
         exeContext,
-        returnTypeNode,
+        returnTypeRef,
         fieldGroup,
         info,
         path,
@@ -582,18 +544,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 +566,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 +576,7 @@ function resolveAndCompleteField(exeContext, returnTypeNode, fieldGroup, info, p
     handleFieldError(
       rawError,
       exeContext,
-      returnTypeNode,
+      returnTypeRef,
       fieldGroup,
       path,
       incrementalDataRecord
@@ -630,14 +584,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 +608,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 +619,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);
-  }
-  if (returnType instanceof GraphQLInputObjectType) {
+  const partialSchema = exeContext.partialSchema;
+  const returnTypeName = typeNameFromReference(returnTypeRef);
+  const leafType = partialSchema.getLeafTypeResolver(returnTypeRef);
+  if (leafType) {
+    return completeLeafValue(leafType, result);
   }
-  if (isUnionResolverType(returnType) || isInterfaceResolverType(returnType)) {
+  if (partialSchema.isAbstractType(returnTypeRef)) {
     return completeAbstractValue(
       exeContext,
-      returnType,
+      returnTypeName,
       fieldGroup,
       info,
       path,
@@ -686,7 +636,7 @@ function completeValue(exeContext, returnTypeNode, fieldGroup, info, path, resul
       incrementalDataRecord
     );
   }
-  if (typeof returnType === "object") {
+  if (partialSchema.isObjectType(returnTypeRef)) {
     return completeObjectValue(
       exeContext,
       returnTypeName,
@@ -698,16 +648,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 +672,7 @@ function completePromisedValue(exeContext, returnTypeNode, fieldGroup, info, pat
       handleFieldError(
         rawError,
         exeContext,
-        returnTypeNode,
+        returnTypeRef,
         fieldGroup,
         path,
         incrementalDataRecord
@@ -732,13 +682,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 +716,7 @@ function completeListValue(exeContext, returnTypeNode, fieldGroup, info, path, r
         exeContext,
         fieldGroup,
         info,
-        itemType,
+        itemTypeRef,
         stream.label,
         previousIncrementalDataRecord
       );
@@ -777,7 +727,7 @@ function completeListValue(exeContext, returnTypeNode, fieldGroup, info, path, r
       item,
       completedResults,
       exeContext,
-      itemType,
+      itemTypeRef,
       fieldGroup,
       info,
       itemPath,
@@ -789,12 +739,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 +757,7 @@ function completeListItemValue(item, completedResults, exeContext, itemTypeNode,
   try {
     const completedItem = completeValue(
       exeContext,
-      itemTypeNode,
+      itemTypeRef,
       fieldGroup,
       info,
       itemPath,
@@ -820,7 +770,7 @@ function completeListItemValue(item, completedResults, exeContext, itemTypeNode,
           handleFieldError(
             rawError,
             exeContext,
-            itemTypeNode,
+            itemTypeRef,
             fieldGroup,
             itemPath,
             incrementalDataRecord
@@ -836,7 +786,7 @@ function completeListItemValue(item, completedResults, exeContext, itemTypeNode,
     handleFieldError(
       rawError,
       exeContext,
-      itemTypeNode,
+      itemTypeRef,
       fieldGroup,
       itemPath,
       incrementalDataRecord
@@ -851,10 +801,9 @@ function getStreamValues(exeContext, fieldGroup, path) {
     return;
   }
   const stream = getDirectiveValues(
+    exeContext,
     GraphQLStreamDirective,
-    fieldGroup[0],
-    exeContext.resolvers,
-    exeContext.variableValues
+    fieldGroup[0]
   );
   if (!stream) {
     return;
@@ -871,7 +820,7 @@ function getStreamValues(exeContext, fieldGroup, path) {
     "initialCount must be a positive integer"
   );
   invariant(
-    exeContext.operation.operation !== OperationTypeNode.SUBSCRIPTION,
+    exeContext.operation.operation !== "subscription",
     "`@stream` directive not supported on subscription operations. Disable `@stream` by setting the `if` argument to `false`."
   );
   return {
@@ -879,7 +828,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 +842,7 @@ function completeAsyncIteratorValue(exeContext, itemType, fieldGroup, info, path
           exeContext,
           fieldGroup,
           info,
-          itemType,
+          itemTypeRef,
           path,
           stream.label,
           incrementalDataRecord
@@ -908,17 +857,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 +885,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.partialSchema.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 +911,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 partialSchema = exeContext.partialSchema;
+  const iface = partialSchema.getInterfaceType(returnTypeName);
+  if (iface) {
+    if (partialSchema.isDefined(runtimeTypeName) && !partialSchema.isObjectType(runtimeTypeName)) {
+      throw new GraphQLError(
+        `Abstract type "${returnTypeName}" was resolved to a non-object type "${runtimeTypeName}".`,
+        { nodes: fieldGroup }
+      );
+    }
+    partialSchema.addInterfaceImplementation(returnTypeName, runtimeTypeName);
   } else {
-    return "Unknown";
+    if (!partialSchema.isDefined(runtimeTypeName)) {
+      throw new GraphQLError(
+        `Abstract type "${returnTypeName}" was resolved to a type "${runtimeTypeName}" that does not exist inside the schema.`,
+        { nodes: fieldGroup }
+      );
+    }
+    if (!partialSchema.isObjectType(runtimeTypeName)) {
+      throw new GraphQLError(
+        `Abstract type "${returnTypeName}" was resolved to a non-object type "${runtimeTypeName}".`,
+        { nodes: fieldGroup }
+      );
+    }
+    if (!exeContext.partialSchema.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(
@@ -1145,12 +1112,17 @@ var defaultFieldResolver = (
 );
 function getOperationRootTypeName(operation) {
   switch (operation.operation) {
-    case OperationTypeNode.QUERY:
+    case "query":
       return "Query";
-    case OperationTypeNode.MUTATION:
+    case "mutation":
       return "Mutation";
-    case OperationTypeNode.SUBSCRIPTION:
+    case "subscription":
       return "Subscription";
+    default:
+      invariant(
+        false,
+        `Operation "${operation.operation}" is not a part of GraphQL spec`
+      );
   }
 }
 function executeDeferredFragment(exeContext, parentTypeName, sourceValue, fields, label, path, parentContext) {
@@ -1182,7 +1154,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 +1164,7 @@ function executeStreamField(path, itemPath, item, exeContext, fieldGroup, info,
   if (isPromise(item)) {
     const completedItems = completePromisedValue(
       exeContext,
-      itemTypeNode,
+      itemTypeRef,
       fieldGroup,
       info,
       itemPath,
@@ -1214,7 +1186,7 @@ function executeStreamField(path, itemPath, item, exeContext, fieldGroup, info,
     try {
       completedItem = completeValue(
         exeContext,
-        itemTypeNode,
+        itemTypeRef,
         fieldGroup,
         info,
         itemPath,
@@ -1225,7 +1197,7 @@ function executeStreamField(path, itemPath, item, exeContext, fieldGroup, info,
       handleFieldError(
         rawError,
         exeContext,
-        itemTypeNode,
+        itemTypeRef,
         fieldGroup,
         itemPath,
         incrementalDataRecord
@@ -1244,7 +1216,7 @@ function executeStreamField(path, itemPath, item, exeContext, fieldGroup, info,
       handleFieldError(
         rawError,
         exeContext,
-        itemTypeNode,
+        itemTypeRef,
         fieldGroup,
         itemPath,
         incrementalDataRecord
@@ -1265,7 +1237,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 +1248,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 +1266,7 @@ function executeStreamAsyncIteratorItem(asyncIterator, exeContext, fieldGroup, i
           handleFieldError(
             rawError,
             exeContext,
-            itemTypeNode,
+            itemTypeRef,
             fieldGroup,
             itemPath,
             incrementalDataRecord
@@ -1312,7 +1280,7 @@ function executeStreamAsyncIteratorItem(asyncIterator, exeContext, fieldGroup, i
       handleFieldError(
         rawError,
         exeContext,
-        itemTypeNode,
+        itemTypeRef,
         fieldGroup,
         itemPath,
         incrementalDataRecord
@@ -1322,7 +1290,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 +1310,7 @@ function executeStreamAsyncIterator(initialIndex, asyncIterator, exeContext, fie
           exeContext,
           fieldGroup,
           info,
-          itemTypeNode,
+          itemTypeRef,
           incrementalDataRecord,
           path,
           itemPath
@@ -1554,11 +1522,19 @@ var StreamItemsRecord = class {
     this.isCompletedAsyncIterator = true;
   }
 };
+function isIncrementalExecutionResult(result) {
+  return "initialResult" in result;
+}
+function isTotalExecutionResult(result) {
+  return !("initialResult" in result);
+}
 export {
   assertValidExecutionArguments,
   buildResolveInfo,
   defaultFieldResolver,
   defaultTypeResolver,
   executeWithoutSchema,
-  getOperationRootTypeName
+  getOperationRootTypeName,
+  isIncrementalExecutionResult,
+  isTotalExecutionResult
 };