@graphitation/supermassive 3.5.0 → 3.5.2

package/lib/executeWithoutSchema.mjs

@@ -185,6 +185,10 @@ function executeOperation(exeContext) {
     );
     const path = void 0;
     let result;
+    const hooks = exeContext.fieldExecutionHooks;
+    if (hooks == null ? void 0 : hooks.beforeOperationExecute) {
+      invokeBeforeOperationExecuteHook(exeContext);
+    }
     switch (operation.operation) {
       case "query":
         result = executeFields(
@@ -242,6 +246,7 @@ function executeOperation(exeContext) {
   }
 }
 function buildResponse(exeContext, data) {
+  var _a, _b;
   if (isPromise(data)) {
     return data.then(
       (resolved) => buildResponse(exeContext, resolved),
@@ -251,6 +256,7 @@ function buildResponse(exeContext, data) {
       }
     );
   }
+  const hooks = exeContext.fieldExecutionHooks;
   try {
     const initialResult = exeContext.errors.length === 0 ? { data } : { errors: exeContext.errors, data };
     if (exeContext.subsequentPayloads.size > 0) {
@@ -261,6 +267,12 @@ function buildResponse(exeContext, data) {
         subsequentResults: yieldSubsequentPayloads(exeContext)
       };
     } else {
+      if (hooks == null ? void 0 : hooks.afterBuildResponse) {
+        invokeAfterBuildResponseHook(exeContext, initialResult);
+        if (exeContext.errors.length > ((_b = (_a = initialResult.errors) == null ? void 0 : _a.length) != null ? _b : 0)) {
+          initialResult.errors = exeContext.errors;
+        }
+      }
       return initialResult;
     }
   } catch (error) {
@@ -432,17 +444,63 @@ function executeSubscriptionImpl(exeContext) {
     typeNameFromReference(returnTypeRef),
     path
   );
+  const isDefaultResolverUsed = resolveFn === exeContext.subscribeFieldResolver;
+  const hooks = exeContext.fieldExecutionHooks;
+  let hookContext = void 0;
   try {
     const args = getArgumentValues(exeContext, fieldDef, fieldGroup[0]);
     const contextValue = exeContext.contextValue;
+    if (!isDefaultResolverUsed && (hooks == null ? void 0 : hooks.beforeFieldResolve)) {
+      hookContext = invokeBeforeFieldResolveHook(info, exeContext);
+    }
     const result = resolveFn(rootValue, args, contextValue, info);
     if (isPromise(result)) {
-      return result.then(assertEventStream).then(void 0, (error) => {
-        throw locatedError(error, fieldGroup, pathToArray(path));
-      });
+      return result.then(assertEventStream).then(
+        (resolved) => {
+          if (!isDefaultResolverUsed && (hooks == null ? void 0 : hooks.afterFieldResolve)) {
+            hookContext = invokeAfterFieldResolveHook(
+              info,
+              exeContext,
+              hookContext,
+              resolved
+            );
+          }
+          return resolved;
+        },
+        (error) => {
+          if (!isDefaultResolverUsed && (hooks == null ? void 0 : hooks.afterFieldResolve)) {
+            hookContext = invokeAfterFieldResolveHook(
+              info,
+              exeContext,
+              hookContext,
+              void 0,
+              error
+            );
+          }
+          throw locatedError(error, fieldGroup, pathToArray(path));
+        }
+      );
     }
-    return assertEventStream(result);
+    const stream = assertEventStream(result);
+    if (!isDefaultResolverUsed && (hooks == null ? void 0 : hooks.afterFieldResolve)) {
+      hookContext = invokeAfterFieldResolveHook(
+        info,
+        exeContext,
+        hookContext,
+        stream
+      );
+    }
+    return stream;
   } catch (error) {
+    if (!isDefaultResolverUsed && (hooks == null ? void 0 : hooks.afterFieldResolve)) {
+      hookContext = invokeAfterFieldResolveHook(
+        info,
+        exeContext,
+        hookContext,
+        void 0,
+        error
+      );
+    }
     throw locatedError(error, fieldGroup, pathToArray(path));
   }
 }
@@ -478,6 +536,10 @@ function mapResultOrEventStreamOrPromise(resultOrStreamOrPromise, exeContext, pa
           exeContext,
           payload
         );
+        const hooks = exeContext == null ? void 0 : exeContext.fieldExecutionHooks;
+        if (hooks == null ? void 0 : hooks.beforeSubscriptionEventEmit) {
+          invokeBeforeSubscriptionEventEmitHook(perEventContext, payload);
+        }
         try {
           const data = executeFields(
             exeContext,
@@ -536,7 +598,7 @@ function resolveAndCompleteField(exeContext, parentTypeName, fieldDefinition, fi
     typeNameFromReference(returnTypeRef),
     path
   );
-  const isDefaultResolverUsed = resolveFn === exeContext.fieldResolver;
+  const isDefaultResolverUsed = resolveFn === exeContext.fieldResolver || fieldName === "__typename";
   const hooks = exeContext.fieldExecutionHooks;
   let hookContext = void 0;
   try {
@@ -546,28 +608,50 @@ function resolveAndCompleteField(exeContext, parentTypeName, fieldDefinition, fi
       hookContext = invokeBeforeFieldResolveHook(info, exeContext);
     }
     const result = resolveFn(source, args, contextValue, info);
-    if (!isDefaultResolverUsed && (hooks == null ? void 0 : hooks.afterFieldResolve)) {
-      hookContext = invokeAfterFieldResolveHook(
-        info,
-        exeContext,
-        hookContext,
-        result
-      );
-    }
     let completed;
     if (isPromise(result)) {
-      completed = result.then((resolved) => {
-        return completeValue(
-          exeContext,
-          returnTypeRef,
-          fieldGroup,
+      completed = result.then(
+        (resolved) => {
+          if (!isDefaultResolverUsed && (hooks == null ? void 0 : hooks.afterFieldResolve)) {
+            hookContext = invokeAfterFieldResolveHook(
+              info,
+              exeContext,
+              hookContext,
+              resolved
+            );
+          }
+          return completeValue(
+            exeContext,
+            returnTypeRef,
+            fieldGroup,
+            info,
+            path,
+            resolved,
+            incrementalDataRecord
+          );
+        },
+        (rawError) => {
+          if (!isDefaultResolverUsed && (hooks == null ? void 0 : hooks.afterFieldResolve)) {
+            hookContext = invokeAfterFieldResolveHook(
+              info,
+              exeContext,
+              hookContext,
+              void 0,
+              rawError
+            );
+          }
+          throw rawError;
+        }
+      );
+    } else {
+      if (!isDefaultResolverUsed && (hooks == null ? void 0 : hooks.afterFieldResolve)) {
+        hookContext = invokeAfterFieldResolveHook(
           info,
-          path,
-          resolved,
-          incrementalDataRecord
+          exeContext,
+          hookContext,
+          result
         );
-      });
-    } else {
+      }
       completed = completeValue(
         exeContext,
         returnTypeRef,
@@ -626,7 +710,8 @@ function resolveAndCompleteField(exeContext, parentTypeName, fieldDefinition, fi
         info,
         exeContext,
         hookContext,
-        void 0
+        void 0,
+        error
       );
     }
     if (!isDefaultResolverUsed && (hooks == null ? void 0 : hooks.afterFieldComplete)) {
@@ -1132,7 +1217,7 @@ function invokeBeforeFieldResolveHook(resolveInfo, exeContext) {
     }
   );
 }
-function invokeAfterFieldResolveHook(resolveInfo, exeContext, hookContext, result) {
+function invokeAfterFieldResolveHook(resolveInfo, exeContext, hookContext, result, error) {
   var _a;
   const hook = (_a = exeContext.fieldExecutionHooks) == null ? void 0 : _a.afterFieldResolve;
   if (!hook) {
@@ -1143,16 +1228,17 @@ function invokeAfterFieldResolveHook(resolveInfo, exeContext, hookContext, resul
       resolveInfo,
       context: exeContext.contextValue,
       hookContext,
-      result
+      result,
+      error
     }),
     (_, rawError) => {
       if (rawError) {
-        const error = toGraphQLError(
+        const error2 = toGraphQLError(
           rawError,
           resolveInfo.path,
           "Unexpected error in afterFieldResolve hook"
         );
-        exeContext.errors.push(error);
+        exeContext.errors.push(error2);
       }
     }
   );
@@ -1183,6 +1269,77 @@ function invokeAfterFieldCompleteHook(resolveInfo, exeContext, hookContext, resu
     }
   );
 }
+function invokeBeforeOperationExecuteHook(exeContext) {
+  var _a;
+  const hook = (_a = exeContext.fieldExecutionHooks) == null ? void 0 : _a.beforeOperationExecute;
+  if (!hook) {
+    return;
+  }
+  return executeSafe(
+    () => hook({
+      context: exeContext.contextValue,
+      operation: exeContext.operation
+    }),
+    (_, rawError) => {
+      if (rawError) {
+        const error = toGraphQLError(
+          rawError,
+          void 0,
+          "Unexpected error in beforeOperationExecute hook"
+        );
+        exeContext.errors.push(error);
+      }
+    }
+  );
+}
+function invokeBeforeSubscriptionEventEmitHook(exeContext, eventPayload) {
+  var _a;
+  const hook = (_a = exeContext.fieldExecutionHooks) == null ? void 0 : _a.beforeSubscriptionEventEmit;
+  if (!hook) {
+    return;
+  }
+  return executeSafe(
+    () => hook({
+      context: exeContext.contextValue,
+      operation: exeContext.operation,
+      eventPayload
+    }),
+    (_, rawError) => {
+      if (rawError) {
+        const error = toGraphQLError(
+          rawError,
+          void 0,
+          "Unexpected error in beforeSubscriptionEventEmit hook"
+        );
+        exeContext.errors.push(error);
+      }
+    }
+  );
+}
+function invokeAfterBuildResponseHook(exeContext, result) {
+  var _a;
+  const hook = (_a = exeContext.fieldExecutionHooks) == null ? void 0 : _a.afterBuildResponse;
+  if (!hook) {
+    return;
+  }
+  return executeSafe(
+    () => hook({
+      context: exeContext.contextValue,
+      operation: exeContext.operation,
+      result
+    }),
+    (_, rawError) => {
+      if (rawError) {
+        const error = toGraphQLError(
+          rawError,
+          void 0,
+          "Unexpected error in afterBuildResponse hook"
+        );
+        exeContext.errors.push(error);
+      }
+    }
+  );
+}
 function executeSafe(execute, onComplete) {
   let error;
   let result;
@@ -1198,7 +1355,7 @@ function executeSafe(execute, onComplete) {
 function toGraphQLError(originalError, path, prependMessage) {
   const originalMessage = originalError instanceof Error ? originalError.message : inspect(originalError);
   const error = new Error(`${prependMessage}: ${originalMessage}`);
-  return locatedError(error, void 0, pathToArray(path));
+  return locatedError(error, void 0, path ? pathToArray(path) : void 0);
 }
 var defaultTypeResolver = function(value) {
   if (isObjectLike(value) && typeof value.__typename === "string") {