@graphitation/supermassive 2.2.2 → 2.3.0

package/lib/executeWithoutSchema.js

@@ -1,3 +1,4 @@
+"use strict";
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
@@ -41,6 +42,7 @@ 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");
 function executeWithoutSchema(args) {
   const {
     resolvers,
@@ -51,11 +53,22 @@ function executeWithoutSchema(args) {
     variableValues,
     operationName,
     fieldResolver,
-    typeResolver
+    typeResolver,
+    fieldExecutionHooks
   } = args;
   const combinedResolvers = (0, import_mergeResolvers.mergeResolvers)(resolvers, schemaResolvers);
   assertValidExecutionArguments(document, variableValues);
-  const exeContext = buildExecutionContext(combinedResolvers, document, rootValue, contextValue, variableValues, operationName, fieldResolver, typeResolver);
+  const exeContext = buildExecutionContext(
+    combinedResolvers,
+    document,
+    rootValue,
+    contextValue,
+    variableValues,
+    operationName,
+    fieldResolver,
+    typeResolver,
+    fieldExecutionHooks
+  );
   if (!("resolvers" in exeContext)) {
     return { errors: exeContext };
   } else {
@@ -65,15 +78,20 @@ function executeWithoutSchema(args) {
 }
 function buildResponse(exeContext, data) {
   if ((0, import_isPromise.isPromise)(data)) {
-    return data.then((resolved) => buildResponse(exeContext, resolved));
+    return data.then(
+      (resolved) => buildResponse(exeContext, resolved)
+    );
   }
   return exeContext.errors.length === 0 ? { data } : { errors: exeContext.errors, data };
 }
 function assertValidExecutionArguments(document, rawVariableValues) {
   (0, import_devAssert.devAssert)(document, "Must provide document.");
-  (0, import_devAssert.devAssert)(rawVariableValues == null || (0, import_isObjectLike.isObjectLike)(rawVariableValues), "Variables must be provided as an Object where each property is a variable value. Perhaps look to see if an unparsed JSON string was provided.");
+  (0, import_devAssert.devAssert)(
+    rawVariableValues == null || (0, import_isObjectLike.isObjectLike)(rawVariableValues),
+    "Variables must be provided as an Object where each property is a variable value. Perhaps look to see if an unparsed JSON string was provided."
+  );
 }
-function buildExecutionContext(resolvers, document, rootValue, contextValue, rawVariableValues, operationName, fieldResolver, typeResolver) {
+function buildExecutionContext(resolvers, document, rootValue, contextValue, rawVariableValues, operationName, fieldResolver, typeResolver, fieldExecutionHooks) {
   var _a, _b;
   let operation;
   const fragments = /* @__PURE__ */ Object.create(null);
@@ -83,7 +101,9 @@ function buildExecutionContext(resolvers, document, rootValue, contextValue, raw
         if (operationName == null) {
           if (operation !== void 0) {
             return [
-              new import_graphql.GraphQLError("Must provide operation name if query contains multiple operations.")
+              new import_graphql.GraphQLError(
+                "Must provide operation name if query contains multiple operations."
+              )
             ];
           }
           operation = definition;
@@ -103,7 +123,12 @@ function buildExecutionContext(resolvers, document, rootValue, contextValue, raw
     return [new import_graphql.GraphQLError("Must provide an operation.")];
   }
   const variableDefinitions = (_b = operation.variableDefinitions) != null ? _b : [];
-  const coercedVariableValues = (0, import_values.getVariableValues)(resolvers, variableDefinitions, rawVariableValues != null ? rawVariableValues : {}, { maxErrors: 50 });
+  const coercedVariableValues = (0, import_values.getVariableValues)(
+    resolvers,
+    variableDefinitions,
+    rawVariableValues != null ? rawVariableValues : {},
+    { maxErrors: 50 }
+  );
   if (coercedVariableValues.errors) {
     return coercedVariableValues.errors;
   }
@@ -116,12 +141,21 @@ function buildExecutionContext(resolvers, document, rootValue, contextValue, raw
     variableValues: coercedVariableValues.coerced,
     fieldResolver: fieldResolver != null ? fieldResolver : defaultFieldResolver,
     typeResolver: typeResolver != null ? typeResolver : defaultTypeResolver,
-    errors: []
+    errors: [],
+    fieldExecutionHooks
   };
 }
 function executeOperation(exeContext, operation, rootValue) {
   const typeName = getOperationRootTypeName(operation);
-  const fields = (0, import_collectFields.collectFields)(exeContext.resolvers, exeContext.fragments, exeContext.variableValues, typeName, operation.selectionSet, /* @__PURE__ */ new Map(), /* @__PURE__ */ new Set());
+  const fields = (0, import_collectFields.collectFields)(
+    exeContext.resolvers,
+    exeContext.fragments,
+    exeContext.variableValues,
+    typeName,
+    operation.selectionSet,
+    /* @__PURE__ */ new Map(),
+    /* @__PURE__ */ new Set()
+  );
   const path = void 0;
   try {
     const result = operation.operation === "mutation" ? executeFieldsSerially(exeContext, typeName, rootValue, path, fields) : executeFields(exeContext, typeName, rootValue, path, fields);
@@ -138,28 +172,44 @@ function executeOperation(exeContext, operation, rootValue) {
   }
 }
 function executeFieldsSerially(exeContext, parentTypeName, sourceValue, path, fields) {
-  return (0, import_promiseReduce.promiseReduce)(fields.entries(), (results, [responseName, fieldNodes]) => {
-    const fieldPath = (0, import_Path.addPath)(path, responseName, parentTypeName);
-    const result = executeField(exeContext, parentTypeName, sourceValue, fieldNodes, fieldPath);
-    if (result === void 0) {
-      return results;
-    }
-    if ((0, import_isPromise.isPromise)(result)) {
-      return result.then((resolvedResult) => {
-        results[responseName] = resolvedResult;
+  return (0, import_promiseReduce.promiseReduce)(
+    fields.entries(),
+    (results, [responseName, fieldNodes]) => {
+      const fieldPath = (0, import_Path.addPath)(path, responseName, parentTypeName);
+      const result = executeField(
+        exeContext,
+        parentTypeName,
+        sourceValue,
+        fieldNodes,
+        fieldPath
+      );
+      if (result === void 0) {
         return results;
-      });
-    }
-    results[responseName] = result;
-    return results;
-  }, /* @__PURE__ */ Object.create(null));
+      }
+      if ((0, import_isPromise.isPromise)(result)) {
+        return result.then((resolvedResult) => {
+          results[responseName] = resolvedResult;
+          return results;
+        });
+      }
+      results[responseName] = result;
+      return results;
+    },
+    /* @__PURE__ */ Object.create(null)
+  );
 }
 function executeFields(exeContext, parentTypeName, sourceValue, path, fields) {
   const results = /* @__PURE__ */ Object.create(null);
   let containsPromise = false;
   for (const [responseName, fieldNodes] of fields.entries()) {
     const fieldPath = (0, import_Path.addPath)(path, responseName, parentTypeName);
-    const result = executeField(exeContext, parentTypeName, sourceValue, fieldNodes, fieldPath);
+    const result = executeField(
+      exeContext,
+      parentTypeName,
+      sourceValue,
+      fieldNodes,
+      fieldPath
+    );
     if (result !== void 0) {
       results[responseName] = result;
       if ((0, import_isPromise.isPromise)(result)) {
@@ -174,6 +224,7 @@ function executeFields(exeContext, parentTypeName, sourceValue, path, fields) {
 }
 function executeField(exeContext, parentTypeName, source, fieldNodes, path) {
   const fieldName = fieldNodes[0].name.value;
+  const hooks = exeContext.fieldExecutionHooks;
   let resolveFn;
   let returnTypeName;
   let returnTypeNode;
@@ -196,29 +247,104 @@ function executeField(exeContext, parentTypeName, source, fieldNodes, path) {
       resolveFn = resolveFn.resolve;
     }
   }
+  const isDefaultResolverUsed = !resolveFn;
   if (!resolveFn) {
     resolveFn = exeContext.fieldResolver;
   }
-  const info = buildResolveInfo(exeContext, fieldName, fieldNodes, parentTypeName, returnTypeName, returnTypeNode, path);
+  const info = buildResolveInfo(
+    exeContext,
+    fieldName,
+    fieldNodes,
+    parentTypeName,
+    returnTypeName,
+    returnTypeNode,
+    path
+  );
   try {
-    const args = (0, import_values.getArgumentValues)(exeContext.resolvers, fieldNodes[0], exeContext.variableValues);
+    const args = (0, import_values.getArgumentValues)(
+      exeContext.resolvers,
+      fieldNodes[0],
+      exeContext.variableValues
+    );
+    if (!isDefaultResolverUsed && (hooks == null ? void 0 : hooks.beforeFieldResolve)) {
+      invokeBeforeFieldResolveHook(info, exeContext);
+    }
     const contextValue = exeContext.contextValue;
     const result = resolveFn(source, args, contextValue, info);
     let completed;
     if ((0, import_isPromise.isPromise)(result)) {
-      completed = result.then((resolved) => completeValue(exeContext, returnTypeNode, fieldNodes, info, path, resolved));
+      completed = result.then(
+        (resolved) => {
+          if (!isDefaultResolverUsed && (hooks == null ? void 0 : hooks.afterFieldResolve)) {
+            invokeAfterFieldResolveHook(info, exeContext, resolved);
+          }
+          return completeValue(
+            exeContext,
+            returnTypeNode,
+            fieldNodes,
+            info,
+            path,
+            resolved
+          );
+        },
+        (rawError) => {
+          if (!isDefaultResolverUsed && (hooks == null ? void 0 : hooks.afterFieldResolve)) {
+            invokeAfterFieldResolveHook(info, exeContext, void 0, rawError);
+          }
+          throw rawError;
+        }
+      );
     } else {
-      completed = completeValue(exeContext, returnTypeNode, fieldNodes, info, path, result);
+      if (!isDefaultResolverUsed && (hooks == null ? void 0 : hooks.afterFieldResolve)) {
+        invokeAfterFieldResolveHook(info, exeContext, result);
+      }
+      completed = completeValue(
+        exeContext,
+        returnTypeNode,
+        fieldNodes,
+        info,
+        path,
+        result
+      );
     }
     if ((0, import_isPromise.isPromise)(completed)) {
-      return completed.then(void 0, (rawError) => {
-        const error = (0, import_graphql.locatedError)(rawError, fieldNodes, (0, import_Path.pathToArray)(path));
-        return handleFieldError(error, returnTypeNode, exeContext);
-      });
+      return completed.then(
+        (resolved) => {
+          if (!isDefaultResolverUsed && (hooks == null ? void 0 : hooks.afterFieldComplete)) {
+            invokeAfterFieldCompleteHook(info, exeContext, resolved);
+          }
+          return resolved;
+        },
+        (rawError) => {
+          const error = (0, import_graphql.locatedError)(
+            rawError,
+            fieldNodes,
+            (0, import_Path.pathToArray)(path)
+          );
+          if (!isDefaultResolverUsed && (hooks == null ? void 0 : hooks.afterFieldComplete)) {
+            invokeAfterFieldCompleteHook(info, exeContext, void 0, error);
+          }
+          return handleFieldError(error, returnTypeNode, exeContext);
+        }
+      );
+    }
+    if (!isDefaultResolverUsed && (hooks == null ? void 0 : hooks.afterFieldComplete)) {
+      invokeAfterFieldCompleteHook(info, exeContext, completed);
     }
     return completed;
   } catch (rawError) {
-    const error = (0, import_graphql.locatedError)(rawError, fieldNodes, (0, import_Path.pathToArray)(path));
+    const pathArray = (0, import_Path.pathToArray)(path);
+    const error = (0, import_graphql.locatedError)(
+      rawError,
+      fieldNodes,
+      pathArray
+    );
+    if (!isDefaultResolverUsed && (hooks == null ? void 0 : hooks.afterFieldResolve) && error.path && (0, import_array.arraysAreEqual)(pathArray, error.path)) {
+      invokeAfterFieldResolveHook(info, exeContext, void 0, error);
+    }
+    if (!isDefaultResolverUsed && (hooks == null ? void 0 : hooks.afterFieldComplete)) {
+      invokeAfterFieldCompleteHook(info, exeContext, void 0, error);
+    }
     return handleFieldError(error, returnTypeNode, exeContext);
   }
 }
@@ -248,9 +374,18 @@ function completeValue(exeContext, returnTypeNode, fieldNodes, info, path, resul
     throw result;
   }
   if (returnTypeNode.kind === import_graphql.Kind.NON_NULL_TYPE) {
-    const completed = completeValue(exeContext, returnTypeNode.type, fieldNodes, info, path, result);
+    const completed = completeValue(
+      exeContext,
+      returnTypeNode.type,
+      fieldNodes,
+      info,
+      path,
+      result
+    );
     if (completed === null) {
-      throw new Error(`Cannot return null for non-nullable field ${info.parentTypeName}.${info.fieldName}.`);
+      throw new Error(
+        `Cannot return null for non-nullable field ${info.parentTypeName}.${info.fieldName}.`
+      );
     }
     return completed;
   }
@@ -258,7 +393,14 @@ function completeValue(exeContext, returnTypeNode, fieldNodes, info, path, resul
     return null;
   }
   if (returnTypeNode.kind === import_graphql.Kind.LIST_TYPE) {
-    return completeListValue(exeContext, returnTypeNode.type, fieldNodes, info, path, result);
+    return completeListValue(
+      exeContext,
+      returnTypeNode.type,
+      fieldNodes,
+      info,
+      path,
+      result
+    );
   }
   const returnTypeName = returnTypeNode.name.value;
   let returnType = exeContext.resolvers[returnTypeName];
@@ -271,16 +413,35 @@ function completeValue(exeContext, returnTypeNode, fieldNodes, info, path, resul
   if (returnType instanceof import_graphql.GraphQLInputObjectType) {
   }
   if ((0, import_definition.isUnionResolverType)(returnType) || (0, import_definition.isInterfaceResolverType)(returnType)) {
-    return completeAbstractValue(exeContext, returnType, fieldNodes, info, path, result);
+    return completeAbstractValue(
+      exeContext,
+      returnType,
+      fieldNodes,
+      info,
+      path,
+      result
+    );
   }
   if (typeof returnType === "object") {
-    return completeObjectValue(exeContext, returnTypeName, fieldNodes, info, path, result);
-  }
-  (0, import_invariant.invariant)(false, "Cannot complete value of unexpected output type: " + (0, import_inspect.inspect)(returnType));
+    return completeObjectValue(
+      exeContext,
+      returnTypeName,
+      fieldNodes,
+      info,
+      path,
+      result
+    );
+  }
+  (0, import_invariant.invariant)(
+    false,
+    "Cannot complete value of unexpected output type: " + (0, import_inspect.inspect)(returnType)
+  );
 }
 function completeListValue(exeContext, returnTypeNode, fieldNodes, info, path, result) {
   if (!(0, import_isIterableObject.isIterableObject)(result)) {
-    throw new import_graphql.GraphQLError(`Expected Iterable, but did not find one for field "${info.parentTypeName}.${info.fieldName}".`);
+    throw new import_graphql.GraphQLError(
+      `Expected Iterable, but did not find one for field "${info.parentTypeName}.${info.fieldName}".`
+    );
   }
   let containsPromise = false;
   const completedResults = Array.from(result, (item, index) => {
@@ -288,20 +449,44 @@ function completeListValue(exeContext, returnTypeNode, fieldNodes, info, path, r
     try {
       let completedItem;
       if ((0, import_isPromise.isPromise)(item)) {
-        completedItem = item.then((resolved) => completeValue(exeContext, returnTypeNode, fieldNodes, info, itemPath, resolved));
+        completedItem = item.then(
+          (resolved) => completeValue(
+            exeContext,
+            returnTypeNode,
+            fieldNodes,
+            info,
+            itemPath,
+            resolved
+          )
+        );
       } else {
-        completedItem = completeValue(exeContext, returnTypeNode, fieldNodes, info, itemPath, item);
+        completedItem = completeValue(
+          exeContext,
+          returnTypeNode,
+          fieldNodes,
+          info,
+          itemPath,
+          item
+        );
       }
       if ((0, import_isPromise.isPromise)(completedItem)) {
         containsPromise = true;
         return completedItem.then(void 0, (rawError) => {
-          const error = (0, import_graphql.locatedError)(rawError, fieldNodes, (0, import_Path.pathToArray)(itemPath));
+          const error = (0, import_graphql.locatedError)(
+            rawError,
+            fieldNodes,
+            (0, import_Path.pathToArray)(itemPath)
+          );
           return handleFieldError(error, returnTypeNode, exeContext);
         });
       }
       return completedItem;
     } catch (rawError) {
-      const error = (0, import_graphql.locatedError)(rawError, fieldNodes, (0, import_Path.pathToArray)(itemPath));
+      const error = (0, import_graphql.locatedError)(
+        rawError,
+        fieldNodes,
+        (0, import_Path.pathToArray)(itemPath)
+      );
       return handleFieldError(error, returnTypeNode, exeContext);
     }
   });
@@ -310,7 +495,9 @@ function completeListValue(exeContext, returnTypeNode, fieldNodes, info, path, r
 function completeLeafValue(returnType, result) {
   const serializedResult = returnType.serialize(result);
   if (serializedResult === void 0) {
-    throw new Error(`Expected a value of type "${(0, import_inspect.inspect)(returnType)}" but received: ${(0, import_inspect.inspect)(result)}`);
+    throw new Error(
+      `Expected a value of type "${(0, import_inspect.inspect)(returnType)}" but received: ${(0, import_inspect.inspect)(result)}`
+    );
   }
   return serializedResult;
 }
@@ -320,19 +507,43 @@ function completeAbstractValue(exeContext, returnType, fieldNodes, info, path, r
   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), fieldNodes, info, path, result));
-  }
-  return completeObjectValue(exeContext, ensureValidRuntimeType(runtimeTypeName, exeContext), fieldNodes, info, path, result);
+    return runtimeTypeName.then(
+      (resolvedRuntimeTypeName) => completeObjectValue(
+        exeContext,
+        ensureValidRuntimeType(resolvedRuntimeTypeName, exeContext),
+        fieldNodes,
+        info,
+        path,
+        result
+      )
+    );
+  }
+  return completeObjectValue(
+    exeContext,
+    ensureValidRuntimeType(runtimeTypeName, exeContext),
+    fieldNodes,
+    info,
+    path,
+    result
+  );
 }
 function ensureValidRuntimeType(runtimeTypeName, exeContext) {
   if (typeof runtimeTypeName !== "string") {
-    throw new import_graphql.GraphQLError(`Could not determine runtime type for abstract type ${runtimeTypeName}`);
+    throw new import_graphql.GraphQLError(
+      `Could not determine runtime type for abstract type ${runtimeTypeName}`
+    );
   }
   const runtimeType = exeContext.resolvers[runtimeTypeName];
   if (!runtimeType) {
-    throw new import_graphql.GraphQLError(`Type "${runtimeTypeName}" does not exist inside the schema.`);
+    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) {
-    throw new import_graphql.GraphQLError(`Given runtime object "${getRuntimeTypeInstanceName(runtimeType)}" type is not a possible type for "${runtimeTypeName}".`);
+    throw new import_graphql.GraphQLError(
+      `Given runtime object "${getRuntimeTypeInstanceName(
+        runtimeType
+      )}" type is not a possible type for "${runtimeTypeName}".`
+    );
   } else {
     return runtimeTypeName;
   }
@@ -353,22 +564,121 @@ function getRuntimeTypeInstanceName(runtimeType) {
   }
 }
 function completeObjectValue(exeContext, returnTypeName, fieldNodes, info, path, result) {
-  const subFieldNodes = collectSubfields(exeContext, returnTypeName, fieldNodes);
+  const subFieldNodes = collectSubfields(
+    exeContext,
+    returnTypeName,
+    fieldNodes
+  );
   return executeFields(exeContext, returnTypeName, result, path, subFieldNodes);
 }
 function invalidReturnTypeError(returnType, result, fieldNodes) {
-  return new import_graphql.GraphQLError(`Expected value of type "${returnType.name}" but got: ${(0, import_inspect.inspect)(result)}.`, fieldNodes);
+  return new import_graphql.GraphQLError(
+    `Expected value of type "${returnType.name}" but got: ${(0, import_inspect.inspect)(result)}.`,
+    fieldNodes
+  );
 }
 function collectSubfields(exeContext, returnTypeName, fieldNodes) {
   let subFieldNodes = /* @__PURE__ */ new Map();
   const visitedFragmentNames = /* @__PURE__ */ new Set();
   for (const node of fieldNodes) {
     if (node.selectionSet) {
-      subFieldNodes = (0, import_collectFields.collectFields)(exeContext.resolvers, exeContext.fragments, exeContext.variableValues, returnTypeName, node.selectionSet, subFieldNodes, visitedFragmentNames);
+      subFieldNodes = (0, import_collectFields.collectFields)(
+        exeContext.resolvers,
+        exeContext.fragments,
+        exeContext.variableValues,
+        returnTypeName,
+        node.selectionSet,
+        subFieldNodes,
+        visitedFragmentNames
+      );
     }
   }
   return subFieldNodes;
 }
+function invokeBeforeFieldResolveHook(resolveInfo, exeContext) {
+  var _a;
+  const hook = (_a = exeContext.fieldExecutionHooks) == null ? void 0 : _a.beforeFieldResolve;
+  if (!hook) {
+    return;
+  }
+  executeSafe(
+    () => hook({
+      resolveInfo,
+      context: exeContext.contextValue
+    }),
+    (_, rawError) => {
+      const error = toGraphQLError(
+        rawError,
+        resolveInfo.path,
+        "Unexpected error in beforeFieldResolve hook"
+      );
+      exeContext.errors.push(error);
+    }
+  );
+}
+function invokeAfterFieldResolveHook(resolveInfo, exeContext, result, error) {
+  var _a;
+  const hook = (_a = exeContext.fieldExecutionHooks) == null ? void 0 : _a.afterFieldResolve;
+  if (!hook) {
+    return;
+  }
+  executeSafe(
+    () => hook({
+      resolveInfo,
+      context: exeContext.contextValue,
+      result,
+      error
+    }),
+    (_, rawError) => {
+      const error2 = toGraphQLError(
+        rawError,
+        resolveInfo.path,
+        "Unexpected error in afterFieldResolve hook"
+      );
+      exeContext.errors.push(error2);
+    }
+  );
+}
+function invokeAfterFieldCompleteHook(resolveInfo, exeContext, result, error) {
+  var _a;
+  const hook = (_a = exeContext.fieldExecutionHooks) == null ? void 0 : _a.afterFieldComplete;
+  if (!hook) {
+    return;
+  }
+  executeSafe(
+    () => hook({
+      resolveInfo,
+      context: exeContext.contextValue,
+      result,
+      error
+    }),
+    (_, rawError) => {
+      const error2 = toGraphQLError(
+        rawError,
+        resolveInfo.path,
+        "Unexpected error in afterFieldComplete hook"
+      );
+      exeContext.errors.push(error2);
+    }
+  );
+}
+function executeSafe(execute, onComplete) {
+  let error;
+  let result;
+  try {
+    result = execute();
+  } catch (e) {
+    error = e;
+  } finally {
+    onComplete(result, error);
+    return result;
+  }
+}
+function toGraphQLError(originalError, path, prependMessage) {
+  const originalMessage = originalError instanceof Error ? originalError.message : (0, import_inspect.inspect)(originalError);
+  const error = new Error(`${prependMessage}: ${originalMessage}`);
+  return (0, import_graphql.locatedError)(error, void 0, (0, import_Path.pathToArray)(path));
+}
 const defaultTypeResolver = function(value) {
   if ((0, import_isObjectLike.isObjectLike)(value) && typeof value.__typename === "string") {
     return value.__typename;