@graphitation/supermassive 3.15.0 → 3.15.2

package/lib/executeWithoutSchema.mjs

@@ -356,7 +356,13 @@ function executeField(exeContext, parentTypeName, source, fieldGroup, path, incr
     fieldName
   });
   if (!loading) {
-    throwIfRootField(parentTypeName, fieldName, fieldGroup, "typeDefinition");
+    handleMissingSchemaError(
+      exeContext,
+      void 0,
+      fieldGroup,
+      path,
+      incrementalDataRecord
+    );
     return void 0;
   }
   return loading.then(() => {
@@ -376,17 +382,16 @@ function executeField(exeContext, parentTypeName, source, fieldGroup, path, incr
         incrementalDataRecord
       );
     }
-    throwIfRootField(parentTypeName, fieldName, fieldGroup, "typeDefinition");
+    handleMissingSchemaError(
+      exeContext,
+      void 0,
+      fieldGroup,
+      path,
+      incrementalDataRecord
+    );
     return void 0;
   });
 }
-function throwIfRootField(parentTypeName, fieldName, fieldGroup, validationTarget) {
-  const isRootField = parentTypeName === "Mutation" || parentTypeName === "Query";
-  if (isRootField) {
-    const message = validationTarget === "typeDefinition" ? `Type definition for ${parentTypeName}.${fieldName} is missing` : validationTarget === "resolver" ? `Resolver for ${parentTypeName}.${fieldName} is missing` : "Unexpected validation target";
-    throw locatedError(new Error(message), fieldGroup);
-  }
-}
 function requestSchemaFragment(exeContext, request) {
   if (!exeContext.schemaFragmentLoader) {
     return;
@@ -429,8 +434,7 @@ function afterFieldSubscribeHandle(resolved, isDefaultResolverUsed, exeContext,
   }
 }
 function executeSubscriptionImpl(exeContext) {
-  var _a;
-  const { operation, rootValue, schemaFragment } = exeContext;
+  const { operation, schemaFragment } = exeContext;
   const rootTypeName = getOperationRootTypeName(operation);
   const { groupedFieldSet } = collectFields(exeContext, rootTypeName);
   const firstRootField = groupedFieldSet.entries().next().value;
@@ -444,12 +448,52 @@ function executeSubscriptionImpl(exeContext) {
     rootTypeName,
     fieldName
   );
-  if (!fieldDef) {
+  if (fieldDef) {
+    return runSubscriptionResolver(
+      exeContext,
+      fieldDef,
+      fieldName,
+      fieldGroup,
+      responseName,
+      rootTypeName
+    );
+  }
+  const loading = requestSchemaFragment(exeContext, {
+    kind: "ReturnType",
+    parentTypeName: rootTypeName,
+    fieldName
+  });
+  if (!loading) {
     throw locatedError(
-      `The subscription field "${fieldName}" is not defined.`,
+      `Type definition for ${rootTypeName}.${fieldName} is missing`,
       fieldGroup
     );
   }
+  return loading.then(() => {
+    const fieldDef2 = Definitions.getField(
+      schemaFragment.definitions,
+      rootTypeName,
+      fieldName
+    );
+    if (fieldDef2 === void 0) {
+      throw locatedError(
+        `Type definition for ${rootTypeName}.${fieldName} is missing`,
+        fieldGroup
+      );
+    }
+    return runSubscriptionResolver(
+      exeContext,
+      fieldDef2,
+      fieldName,
+      fieldGroup,
+      responseName,
+      rootTypeName
+    );
+  });
+}
+function runSubscriptionResolver(exeContext, fieldDef, fieldName, fieldGroup, responseName, rootTypeName) {
+  var _a;
+  const { rootValue, schemaFragment } = exeContext;
   const returnTypeRef = Definitions.getFieldTypeReference(fieldDef);
   const resolveFn = (_a = Resolvers.getSubscriptionFieldResolver(
     schemaFragment,
@@ -620,12 +664,30 @@ function buildResolveInfo(exeContext, fieldName, fieldGroup, parentTypeName, ret
 function handleFieldError(rawError, exeContext, returnTypeRef, fieldGroup, path, incrementalDataRecord) {
   var _a;
   const error = locatedError(rawError, fieldGroup, pathToArray(path));
-  if (isNonNullType(returnTypeRef)) {
+  if (returnTypeRef && isNonNullType(returnTypeRef)) {
     throw error;
   }
   const errors = (_a = incrementalDataRecord == null ? void 0 : incrementalDataRecord.errors) != null ? _a : exeContext.errors;
   errors.push(error);
 }
+function handleMissingSchemaError(exeContext, returnTypeRef, fieldGroup, path, incrementalDataRecord) {
+  const parentTypeName = path.typename;
+  const isRootField = parentTypeName === "Mutation" || parentTypeName === "Query";
+  if (!isRootField) {
+    return;
+  }
+  const fieldName = path.key;
+  const message = !returnTypeRef ? `Type definition for ${parentTypeName}.${fieldName} is missing` : `Resolver for ${parentTypeName}.${fieldName} is missing`;
+  const error = new Error(message);
+  handleFieldError(
+    error,
+    exeContext,
+    returnTypeRef,
+    fieldGroup,
+    path,
+    incrementalDataRecord
+  );
+}
 function resolveAndCompleteField(exeContext, parentTypeName, fieldDefinition, fieldGroup, path, source, incrementalDataRecord) {
   var _a;
   const fieldName = fieldGroup[0].name.value;
@@ -645,7 +707,13 @@ function resolveAndCompleteField(exeContext, parentTypeName, fieldDefinition, fi
   );
   const isDefaultResolverUsed = resolveFn === exeContext.fieldResolver || fieldName === "__typename";
   if (resolveFn === exeContext.fieldResolver && typeof source === "undefined") {
-    throwIfRootField(parentTypeName, fieldName, fieldGroup, "resolver");
+    handleMissingSchemaError(
+      exeContext,
+      returnTypeRef,
+      fieldGroup,
+      path,
+      incrementalDataRecord
+    );
   }
   const hooks = exeContext.fieldExecutionHooks;
   let hookContext = void 0;