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

package/lib/executeWithoutSchema.js

@@ -64,7 +64,6 @@ __export(executeWithoutSchema_exports, {
 });
 module.exports = __toCommonJS(executeWithoutSchema_exports);
 var import_graphql = require("graphql");
-var import_supermassive_ast = require("./supermassive-ast");
 var import_collectFields = require("./collectFields");
 var import_devAssert = require("./jsutils/devAssert");
 var import_inspect = require("./jsutils/inspect");
@@ -75,28 +74,22 @@ var import_isPromise = require("./jsutils/isPromise");
 var import_Path = require("./jsutils/Path");
 var import_promiseForObject = require("./jsutils/promiseForObject");
 var import_promiseReduce = require("./jsutils/promiseReduce");
-var import_definition = require("./definition");
-var import_mergeResolvers = require("./utilities/mergeResolvers");
-var import_typeNameFromAST = require("./utilities/typeNameFromAST");
 var import_values = require("./values");
 var import_array = require("./utilities/array");
 var import_isAsyncIterable = require("./jsutils/isAsyncIterable");
 var import_mapAsyncIterator = require("./utilities/mapAsyncIterator");
-var import_directives = require("./directives");
+var import_directives = require("./schema/directives");
 var import_memoize3 = require("./jsutils/memoize3");
+var import_fragment = require("./schema/fragment");
+var import_reference = require("./schema/reference");
+var import_getSchemaFragment = require("./utilities/getSchemaFragment");
+var import_mergeDefinitions = require("./utilities/mergeDefinitions");
 const collectSubfields = (0, import_memoize3.memoize3)(
-  (exeContext, returnTypeName, fieldGroup) => (0, import_collectFields.collectSubfields)(
-    exeContext.resolvers,
-    exeContext.fragments,
-    exeContext.variableValues,
-    exeContext.operation,
-    returnTypeName.name,
-    fieldGroup
-  )
+  (exeContext, returnTypeName, fieldGroup) => (0, import_collectFields.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);
@@ -113,7 +106,7 @@ function buildExecutionContext(args) {
   var _a, _b;
   const {
     resolvers,
-    schemaResolvers,
+    schemaFragment: explicitSchemaFragment,
     document,
     rootValue,
     contextValue,
@@ -126,7 +119,6 @@ function buildExecutionContext(args) {
     fieldExecutionHooks
   } = args;
   assertValidExecutionArguments(document, variableValues);
-  const combinedResolvers = schemaResolvers ? (0, import_mergeResolvers.mergeResolvers)(resolvers, schemaResolvers) : resolvers;
   let operation;
   const fragments = /* @__PURE__ */ Object.create(null);
   for (const definition of document.definitions) {
@@ -156,9 +148,24 @@ function buildExecutionContext(args) {
     }
     return [new import_graphql.GraphQLError("Must provide an operation.")];
   }
+  let schemaFragment = explicitSchemaFragment;
+  if (!schemaFragment) {
+    schemaFragment = (0, import_getSchemaFragment.getSchemaFragment)(operation);
+    if (schemaFragment && !schemaFragment.__merged) {
+      (0, import_mergeDefinitions.mergeSchemaDefinitions)(
+        schemaFragment,
+        Object.values(fragments).map((fragmentDef) => (0, import_getSchemaFragment.getSchemaFragment)(fragmentDef)).filter((f) => Boolean(f))
+      );
+      schemaFragment.__merged = true;
+    }
+  }
+  if (!schemaFragment) {
+    return [new import_graphql.GraphQLError("Must provide schema fragment.")];
+  }
   const variableDefinitions = (_b = operation.variableDefinitions) != null ? _b : [];
+  const schemaTypes = new import_fragment.SchemaFragment(schemaFragment, resolvers);
   const coercedVariableValues = (0, import_values.getVariableValues)(
-    combinedResolvers,
+    schemaTypes,
     variableDefinitions,
     variableValues != null ? variableValues : {},
     { maxErrors: 50 }
@@ -167,7 +174,7 @@ function buildExecutionContext(args) {
     return coercedVariableValues.errors;
   }
   return {
-    resolvers: combinedResolvers,
+    schemaTypes,
     fragments,
     rootValue,
     contextValue: buildContextValue ? buildContextValue(contextValue) : contextValue,
@@ -191,19 +198,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 } = (0, import_collectFields.collectFields)(
-    resolvers,
-    fragments,
-    variableValues,
-    rootTypeName,
-    operation
-  );
+  const { groupedFieldSet, patches } = (0, import_collectFields.collectFields)(exeContext, rootTypeName);
   const path = void 0;
   let result;
   switch (operation.operation) {
-    case import_supermassive_ast.OperationTypeNode.QUERY:
+    case import_graphql.OperationTypeNode.QUERY:
       result = executeFields(
         exeContext,
         rootTypeName,
@@ -214,7 +215,7 @@ function executeOperation(exeContext) {
       );
       result = buildResponse(exeContext, result);
       break;
-    case import_supermassive_ast.OperationTypeNode.MUTATION:
+    case import_graphql.OperationTypeNode.MUTATION:
       result = executeFieldsSerially(
         exeContext,
         rootTypeName,
@@ -224,7 +225,7 @@ function executeOperation(exeContext) {
       );
       result = buildResponse(exeContext, result);
       break;
-    case import_supermassive_ast.OperationTypeNode.SUBSCRIPTION: {
+    case import_graphql.OperationTypeNode.SUBSCRIPTION: {
       const resultOrStreamOrPromise = createSourceEventStream(exeContext);
       result = mapResultOrEventStreamOrPromise(
         resultOrStreamOrPromise,
@@ -329,52 +330,34 @@ function executeFields(exeContext, parentTypeName, sourceValue, path, groupedFie
   return (0, import_promiseForObject.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: import_graphql.Kind.NAMED_TYPE,
-      name: {
-        kind: import_graphql.Kind.NAME,
-        value: "String"
-      }
-    };
-  } else {
-    returnTypeNode = fieldGroup[0].__type;
-    returnTypeName = (0, import_typeNameFromAST.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,
+    (0, import_reference.typeNameFromReference)(returnTypeRef),
     path
   );
   return resolveAndCompleteField(
     exeContext,
-    returnTypeNode,
+    parentTypeName,
+    returnTypeRef,
+    fieldDef,
     fieldGroup,
     info,
     path,
     resolveFn,
     source,
-    incrementalDataRecord,
-    isDefaultResolverUsed
+    incrementalDataRecord
   );
 }
 function createSourceEventStream(exeContext) {
@@ -389,71 +372,43 @@ function createSourceEventStream(exeContext) {
   }
 }
 function executeSubscriptionImpl(exeContext) {
-  const { resolvers, fragments, operation, variableValues, rootValue } = exeContext;
-  const typeName = getOperationRootTypeName(operation);
-  const { groupedFieldSet } = (0, import_collectFields.collectFields)(
-    resolvers,
-    fragments,
-    variableValues,
-    typeName,
-    operation
-  );
+  var _a;
+  const { operation, rootValue, schemaTypes } = exeContext;
+  const rootTypeName = getOperationRootTypeName(operation);
+  const { groupedFieldSet } = (0, import_collectFields.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: import_graphql.Kind.NAMED_TYPE,
-      name: {
-        kind: import_graphql.Kind.NAME,
-        value: "String"
-      }
-    };
-  } else {
-    returnTypeNode = fieldGroup[0].__type;
-    returnTypeName = (0, import_typeNameFromAST.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 import_graphql.GraphQLError(
+      `The subscription field "${fieldName}" is not defined.`,
+      { nodes: fieldGroup }
+    );
   }
-  const path = (0, import_Path.addPath)(void 0, responseName, typeName);
+  const returnTypeRef = schemaTypes.getTypeReference(fieldDef);
+  const resolveFn = (_a = schemaTypes.getSubscriptionFieldResolver(rootTypeName, fieldName)) != null ? _a : exeContext.subscribeFieldResolver;
+  const path = (0, import_Path.addPath)(void 0, responseName, rootTypeName);
   const info = buildResolveInfo(
     exeContext,
     fieldName,
     fieldGroup,
-    typeName,
-    returnTypeName,
-    returnTypeNode,
+    rootTypeName,
+    (0, import_reference.typeNameFromReference)(returnTypeRef),
     path
   );
   try {
-    const args = (0, import_values.getArgumentValues)(resolvers, fieldGroup[0], variableValues);
+    const args = (0, import_values.getArgumentValues)(exeContext, fieldDef, fieldGroup[0]);
     const contextValue = exeContext.contextValue;
     const result = resolveFn(rootValue, args, contextValue, info);
     if ((0, import_isPromise.isPromise)(result)) {
       return result.then(assertEventStream).then(void 0, (error) => {
-        throw (0, import_graphql.locatedError)(
-          error,
-          fieldGroup,
-          (0, import_Path.pathToArray)(path)
-        );
+        throw (0, import_graphql.locatedError)(error, fieldGroup, (0, import_Path.pathToArray)(path));
       });
     }
     return assertEventStream(result);
   } catch (error) {
-    throw (0, import_graphql.locatedError)(
-      error,
-      fieldGroup,
-      (0, import_Path.pathToArray)(path)
-    );
+    throw (0, import_graphql.locatedError)(error, fieldGroup, (0, import_Path.pathToArray)(path));
   }
 }
 function assertEventStream(result) {
@@ -501,13 +456,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,
@@ -515,27 +469,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 = (0, import_graphql.locatedError)(
-    rawError,
-    fieldGroup,
-    (0, import_Path.pathToArray)(path)
-  );
-  if (returnTypeNode.kind === import_graphql.Kind.NON_NULL_TYPE) {
+  const error = (0, import_graphql.locatedError)(rawError, fieldGroup, (0, import_Path.pathToArray)(path));
+  if ((0, import_reference.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 = (0, import_values.getArgumentValues)(
-      exeContext.resolvers,
-      fieldGroup[0],
-      exeContext.variableValues
-    );
+    const args = (0, import_values.getArgumentValues)(exeContext, fieldDefinition, fieldGroup[0]);
     const contextValue = exeContext.contextValue;
     if (!isDefaultResolverUsed && (hooks == null ? void 0 : hooks.beforeFieldResolve)) {
       invokeBeforeFieldResolveHook(info, exeContext);
@@ -550,7 +497,7 @@ function resolveAndCompleteField(exeContext, returnTypeNode, fieldGroup, info, p
           }
           return completeValue(
             exeContext,
-            returnTypeNode,
+            returnTypeRef,
             fieldGroup,
             info,
             path,
@@ -571,7 +518,7 @@ function resolveAndCompleteField(exeContext, returnTypeNode, fieldGroup, info, p
       }
       completed = completeValue(
         exeContext,
-        returnTypeNode,
+        returnTypeRef,
         fieldGroup,
         info,
         path,
@@ -588,18 +535,14 @@ function resolveAndCompleteField(exeContext, returnTypeNode, fieldGroup, info, p
           return resolved;
         },
         (rawError) => {
-          const error = (0, import_graphql.locatedError)(
-            rawError,
-            fieldGroup,
-            (0, import_Path.pathToArray)(path)
-          );
+          const error = (0, import_graphql.locatedError)(rawError, fieldGroup, (0, import_Path.pathToArray)(path));
           if (!isDefaultResolverUsed && (hooks == null ? void 0 : hooks.afterFieldComplete)) {
             invokeAfterFieldCompleteHook(info, exeContext, void 0, error);
           }
           handleFieldError(
             rawError,
             exeContext,
-            returnTypeNode,
+            returnTypeRef,
             fieldGroup,
             path,
             incrementalDataRecord
@@ -614,11 +557,7 @@ function resolveAndCompleteField(exeContext, returnTypeNode, fieldGroup, info, p
     return completed;
   } catch (rawError) {
     const pathArray = (0, import_Path.pathToArray)(path);
-    const error = (0, import_graphql.locatedError)(
-      rawError,
-      fieldGroup,
-      pathArray
-    );
+    const error = (0, import_graphql.locatedError)(rawError, fieldGroup, pathArray);
     if (!isDefaultResolverUsed && (hooks == null ? void 0 : hooks.afterFieldResolve) && error.path && (0, import_array.arraysAreEqual)(pathArray, error.path)) {
       invokeAfterFieldResolveHook(info, exeContext, void 0, error);
     }
@@ -628,7 +567,7 @@ function resolveAndCompleteField(exeContext, returnTypeNode, fieldGroup, info, p
     handleFieldError(
       rawError,
       exeContext,
-      returnTypeNode,
+      returnTypeRef,
       fieldGroup,
       path,
       incrementalDataRecord
@@ -636,14 +575,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 === import_graphql.Kind.NON_NULL_TYPE) {
+  if ((0, import_reference.isNonNullType)(returnTypeRef)) {
     const completed = completeValue(
       exeContext,
-      returnTypeNode.type,
+      (0, import_reference.unwrap)(returnTypeRef),
       fieldGroup,
       info,
       path,
@@ -660,10 +599,10 @@ function completeValue(exeContext, returnTypeNode, fieldGroup, info, path, resul
   if (result == null) {
     return null;
   }
-  if (returnTypeNode.kind === import_graphql.Kind.LIST_TYPE) {
+  if ((0, import_reference.isListType)(returnTypeRef)) {
     return completeListValue(
       exeContext,
-      returnTypeNode,
+      returnTypeRef,
       fieldGroup,
       info,
       path,
@@ -671,20 +610,16 @@ function completeValue(exeContext, returnTypeNode, fieldGroup, info, path, resul
       incrementalDataRecord
     );
   }
-  const returnTypeName = returnTypeNode.name.value;
-  let returnType = exeContext.resolvers[returnTypeName];
-  if (!returnType) {
-    returnType = import_values.specifiedScalars[returnTypeName];
-  }
-  if ((0, import_graphql.isLeafType)(returnType)) {
-    return completeLeafValue(returnType, result);
+  const schemaTypes = exeContext.schemaTypes;
+  const returnTypeName = (0, import_reference.typeNameFromReference)(returnTypeRef);
+  const leafType = schemaTypes.getLeafTypeResolver(returnTypeRef);
+  if (leafType) {
+    return completeLeafValue(leafType, result);
   }
-  if (returnType instanceof import_graphql.GraphQLInputObjectType) {
-  }
-  if ((0, import_definition.isUnionResolverType)(returnType) || (0, import_definition.isInterfaceResolverType)(returnType)) {
+  if (schemaTypes.isAbstractType(returnTypeRef)) {
     return completeAbstractValue(
       exeContext,
-      returnType,
+      returnTypeName,
       fieldGroup,
       info,
       path,
@@ -692,7 +627,7 @@ function completeValue(exeContext, returnTypeNode, fieldGroup, info, path, resul
       incrementalDataRecord
     );
   }
-  if (typeof returnType === "object") {
+  if (schemaTypes.isObjectType(returnTypeRef)) {
     return completeObjectValue(
       exeContext,
       returnTypeName,
@@ -704,16 +639,16 @@ function completeValue(exeContext, returnTypeNode, fieldGroup, info, path, resul
   }
   (0, import_invariant.invariant)(
     false,
-    "Cannot complete value of unexpected output type: " + (0, import_inspect.inspect)(returnType)
+    "Cannot complete value of unexpected output type: " + (0, import_reference.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,
@@ -728,7 +663,7 @@ function completePromisedValue(exeContext, returnTypeNode, fieldGroup, info, pat
       handleFieldError(
         rawError,
         exeContext,
-        returnTypeNode,
+        returnTypeRef,
         fieldGroup,
         path,
         incrementalDataRecord
@@ -738,13 +673,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 = (0, import_reference.unwrap)(returnTypeRef);
   if ((0, import_isAsyncIterable.isAsyncIterable)(result)) {
     const asyncIterator = result[Symbol.asyncIterator]();
     return completeAsyncIteratorValue(
       exeContext,
-      itemType,
+      itemTypeRef,
       fieldGroup,
       info,
       path,
@@ -772,7 +707,7 @@ function completeListValue(exeContext, returnTypeNode, fieldGroup, info, path, r
         exeContext,
         fieldGroup,
         info,
-        itemType,
+        itemTypeRef,
         stream.label,
         previousIncrementalDataRecord
       );
@@ -783,7 +718,7 @@ function completeListValue(exeContext, returnTypeNode, fieldGroup, info, path, r
       item,
       completedResults,
       exeContext,
-      itemType,
+      itemTypeRef,
       fieldGroup,
       info,
       itemPath,
@@ -795,12 +730,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 ((0, import_isPromise.isPromise)(item)) {
     completedResults.push(
       completePromisedValue(
         exeContext,
-        itemTypeNode,
+        itemTypeRef,
         fieldGroup,
         info,
         itemPath,
@@ -813,7 +748,7 @@ function completeListItemValue(item, completedResults, exeContext, itemTypeNode,
   try {
     const completedItem = completeValue(
       exeContext,
-      itemTypeNode,
+      itemTypeRef,
       fieldGroup,
       info,
       itemPath,
@@ -826,7 +761,7 @@ function completeListItemValue(item, completedResults, exeContext, itemTypeNode,
           handleFieldError(
             rawError,
             exeContext,
-            itemTypeNode,
+            itemTypeRef,
             fieldGroup,
             itemPath,
             incrementalDataRecord
@@ -842,7 +777,7 @@ function completeListItemValue(item, completedResults, exeContext, itemTypeNode,
     handleFieldError(
       rawError,
       exeContext,
-      itemTypeNode,
+      itemTypeRef,
       fieldGroup,
       itemPath,
       incrementalDataRecord
@@ -857,10 +792,9 @@ function getStreamValues(exeContext, fieldGroup, path) {
     return;
   }
   const stream = (0, import_values.getDirectiveValues)(
+    exeContext,
     import_directives.GraphQLStreamDirective,
-    fieldGroup[0],
-    exeContext.resolvers,
-    exeContext.variableValues
+    fieldGroup[0]
   );
   if (!stream) {
     return;
@@ -877,7 +811,7 @@ function getStreamValues(exeContext, fieldGroup, path) {
     "initialCount must be a positive integer"
   );
   (0, import_invariant.invariant)(
-    exeContext.operation.operation !== import_supermassive_ast.OperationTypeNode.SUBSCRIPTION,
+    exeContext.operation.operation !== import_graphql.OperationTypeNode.SUBSCRIPTION,
     "`@stream` directive not supported on subscription operations. Disable `@stream` by setting the `if` argument to `false`."
   );
   return {
@@ -885,7 +819,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;
@@ -899,7 +833,7 @@ function completeAsyncIteratorValue(exeContext, itemType, fieldGroup, info, path
           exeContext,
           fieldGroup,
           info,
-          itemType,
+          itemTypeRef,
           path,
           stream.label,
           incrementalDataRecord
@@ -914,17 +848,13 @@ function completeAsyncIteratorValue(exeContext, itemType, fieldGroup, info, path
           break;
         }
       } catch (rawError) {
-        throw (0, import_graphql.locatedError)(
-          rawError,
-          fieldGroup,
-          (0, import_Path.pathToArray)(path)
-        );
+        throw (0, import_graphql.locatedError)(rawError, fieldGroup, (0, import_Path.pathToArray)(path));
       }
       if (completeListItemValue(
         iteration.value,
         completedResults,
         exeContext,
-        itemType,
+        itemTypeRef,
         fieldGroup,
         info,
         itemPath,
@@ -946,16 +876,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 ((0, import_isPromise.isPromise)(runtimeTypeName)) {
     return runtimeTypeName.then(
       (resolvedRuntimeTypeName) => completeObjectValue(
         exeContext,
-        ensureValidRuntimeType(resolvedRuntimeTypeName, exeContext),
+        ensureValidRuntimeType(
+          resolvedRuntimeTypeName,
+          exeContext,
+          returnTypeName,
+          fieldGroup,
+          info,
+          result
+        ),
         fieldGroup,
         path,
         result,
@@ -965,48 +902,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 import_graphql.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 import_graphql.GraphQLError(
-      `Type "${runtimeTypeName}" does not exist inside the schema.`
-    );
-  } else if (runtimeType instanceof import_graphql.GraphQLScalarType || runtimeType instanceof import_graphql.GraphQLEnumType || runtimeType instanceof import_graphql.GraphQLInputObjectType || runtimeType.__resolveType) {
+  if (typeof runtimeTypeName !== "string") {
     throw new import_graphql.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 ${(0, import_inspect.inspect)(result)}, received "${(0, import_inspect.inspect)(runtimeTypeName)}".`
     );
-  } else {
-    return runtimeTypeName;
   }
-}
-function getRuntimeTypeInstanceName(runtimeType) {
-  if (runtimeType instanceof import_graphql.GraphQLScalarType) {
-    return "GraphQLScalarType";
-  } else if (runtimeType instanceof import_graphql.GraphQLEnumType) {
-    return "GraphQLEnumType";
-  } else if (runtimeType instanceof import_graphql.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 import_graphql.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 import_graphql.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 import_graphql.GraphQLError(
+        `Abstract type "${returnTypeName}" was resolved to a non-object type "${runtimeTypeName}".`,
+        { nodes: fieldGroup }
+      );
+    }
+    if (!exeContext.schemaTypes.isSubType(returnTypeName, runtimeTypeName)) {
+      throw new import_graphql.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(
@@ -1151,11 +1103,11 @@ const defaultFieldResolver = (
 );
 function getOperationRootTypeName(operation) {
   switch (operation.operation) {
-    case import_supermassive_ast.OperationTypeNode.QUERY:
+    case import_graphql.OperationTypeNode.QUERY:
       return "Query";
-    case import_supermassive_ast.OperationTypeNode.MUTATION:
+    case import_graphql.OperationTypeNode.MUTATION:
       return "Mutation";
-    case import_supermassive_ast.OperationTypeNode.SUBSCRIPTION:
+    case import_graphql.OperationTypeNode.SUBSCRIPTION:
       return "Subscription";
   }
 }
@@ -1188,7 +1140,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,
@@ -1198,7 +1150,7 @@ function executeStreamField(path, itemPath, item, exeContext, fieldGroup, info,
   if ((0, import_isPromise.isPromise)(item)) {
     const completedItems = completePromisedValue(
       exeContext,
-      itemTypeNode,
+      itemTypeRef,
       fieldGroup,
       info,
       itemPath,
@@ -1220,7 +1172,7 @@ function executeStreamField(path, itemPath, item, exeContext, fieldGroup, info,
     try {
       completedItem = completeValue(
         exeContext,
-        itemTypeNode,
+        itemTypeRef,
         fieldGroup,
         info,
         itemPath,
@@ -1231,7 +1183,7 @@ function executeStreamField(path, itemPath, item, exeContext, fieldGroup, info,
       handleFieldError(
         rawError,
         exeContext,
-        itemTypeNode,
+        itemTypeRef,
         fieldGroup,
         itemPath,
         incrementalDataRecord
@@ -1250,7 +1202,7 @@ function executeStreamField(path, itemPath, item, exeContext, fieldGroup, info,
       handleFieldError(
         rawError,
         exeContext,
-        itemTypeNode,
+        itemTypeRef,
         fieldGroup,
         itemPath,
         incrementalDataRecord
@@ -1271,7 +1223,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 {
@@ -1282,17 +1234,13 @@ function executeStreamAsyncIteratorItem(asyncIterator, exeContext, fieldGroup, i
       }
       item = value;
     } catch (rawError) {
-      throw (0, import_graphql.locatedError)(
-        rawError,
-        fieldGroup,
-        (0, import_Path.pathToArray)(path)
-      );
+      throw (0, import_graphql.locatedError)(rawError, fieldGroup, (0, import_Path.pathToArray)(path));
     }
     let completedItem;
     try {
       completedItem = completeValue(
         exeContext,
-        itemTypeNode,
+        itemTypeRef,
         fieldGroup,
         info,
         itemPath,
@@ -1304,7 +1252,7 @@ function executeStreamAsyncIteratorItem(asyncIterator, exeContext, fieldGroup, i
           handleFieldError(
             rawError,
             exeContext,
-            itemTypeNode,
+            itemTypeRef,
             fieldGroup,
             itemPath,
             incrementalDataRecord
@@ -1318,7 +1266,7 @@ function executeStreamAsyncIteratorItem(asyncIterator, exeContext, fieldGroup, i
       handleFieldError(
         rawError,
         exeContext,
-        itemTypeNode,
+        itemTypeRef,
         fieldGroup,
         itemPath,
         incrementalDataRecord
@@ -1328,7 +1276,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;
@@ -1348,7 +1296,7 @@ function executeStreamAsyncIterator(initialIndex, asyncIterator, exeContext, fie
           exeContext,
           fieldGroup,
           info,
-          itemTypeNode,
+          itemTypeRef,
           incrementalDataRecord,
           path,
           itemPath