@graphitation/supermassive 2.2.2 → 2.3.0

package/lib/executeWithoutSchema.mjs

@@ -26,6 +26,7 @@ import {
   getVariableValues,
   specifiedScalars
 } from "./values.mjs";
+import { arraysAreEqual } from "./utilities/array.mjs";
 function executeWithoutSchema(args) {
   const {
     resolvers,
@@ -36,11 +37,22 @@ function executeWithoutSchema(args) {
     variableValues,
     operationName,
     fieldResolver,
-    typeResolver
+    typeResolver,
+    fieldExecutionHooks
   } = args;
   const combinedResolvers = 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 {
@@ -50,15 +62,20 @@ function executeWithoutSchema(args) {
 }
 function buildResponse(exeContext, data) {
   if (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) {
   devAssert(document, "Must provide document.");
-  devAssert(rawVariableValues == null || 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.");
+  devAssert(
+    rawVariableValues == null || 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);
@@ -68,7 +85,9 @@ function buildExecutionContext(resolvers, document, rootValue, contextValue, raw
         if (operationName == null) {
           if (operation !== void 0) {
             return [
-              new GraphQLError("Must provide operation name if query contains multiple operations.")
+              new GraphQLError(
+                "Must provide operation name if query contains multiple operations."
+              )
             ];
           }
           operation = definition;
@@ -88,7 +107,12 @@ function buildExecutionContext(resolvers, document, rootValue, contextValue, raw
     return [new GraphQLError("Must provide an operation.")];
   }
   const variableDefinitions = (_b = operation.variableDefinitions) != null ? _b : [];
-  const coercedVariableValues = getVariableValues(resolvers, variableDefinitions, rawVariableValues != null ? rawVariableValues : {}, { maxErrors: 50 });
+  const coercedVariableValues = getVariableValues(
+    resolvers,
+    variableDefinitions,
+    rawVariableValues != null ? rawVariableValues : {},
+    { maxErrors: 50 }
+  );
   if (coercedVariableValues.errors) {
     return coercedVariableValues.errors;
   }
@@ -101,12 +125,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 = collectFields(exeContext.resolvers, exeContext.fragments, exeContext.variableValues, typeName, operation.selectionSet, /* @__PURE__ */ new Map(), /* @__PURE__ */ new Set());
+  const fields = 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);
@@ -123,28 +156,44 @@ function executeOperation(exeContext, operation, rootValue) {
   }
 }
 function executeFieldsSerially(exeContext, parentTypeName, sourceValue, path, fields) {
-  return promiseReduce(fields.entries(), (results, [responseName, fieldNodes]) => {
-    const fieldPath = addPath(path, responseName, parentTypeName);
-    const result = executeField(exeContext, parentTypeName, sourceValue, fieldNodes, fieldPath);
-    if (result === void 0) {
-      return results;
-    }
-    if (isPromise(result)) {
-      return result.then((resolvedResult) => {
-        results[responseName] = resolvedResult;
+  return promiseReduce(
+    fields.entries(),
+    (results, [responseName, fieldNodes]) => {
+      const fieldPath = 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 (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 = 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 (isPromise(result)) {
@@ -159,6 +208,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;
@@ -181,29 +231,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 = getArgumentValues(exeContext.resolvers, fieldNodes[0], exeContext.variableValues);
+    const args = 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 (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 (isPromise(completed)) {
-      return completed.then(void 0, (rawError) => {
-        const error = locatedError(rawError, fieldNodes, 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 = locatedError(
+            rawError,
+            fieldNodes,
+            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 = locatedError(rawError, fieldNodes, pathToArray(path));
+    const pathArray = pathToArray(path);
+    const error = locatedError(
+      rawError,
+      fieldNodes,
+      pathArray
+    );
+    if (!isDefaultResolverUsed && (hooks == null ? void 0 : hooks.afterFieldResolve) && error.path && 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);
   }
 }
@@ -233,9 +358,18 @@ function completeValue(exeContext, returnTypeNode, fieldNodes, info, path, resul
     throw result;
   }
   if (returnTypeNode.kind === 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;
   }
@@ -243,7 +377,14 @@ function completeValue(exeContext, returnTypeNode, fieldNodes, info, path, resul
     return null;
   }
   if (returnTypeNode.kind === 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];
@@ -256,16 +397,35 @@ function completeValue(exeContext, returnTypeNode, fieldNodes, info, path, resul
   if (returnType instanceof GraphQLInputObjectType) {
   }
   if (isUnionResolverType(returnType) || 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);
+    return completeObjectValue(
+      exeContext,
+      returnTypeName,
+      fieldNodes,
+      info,
+      path,
+      result
+    );
   }
-  invariant(false, "Cannot complete value of unexpected output type: " + inspect(returnType));
+  invariant(
+    false,
+    "Cannot complete value of unexpected output type: " + inspect(returnType)
+  );
 }
 function completeListValue(exeContext, returnTypeNode, fieldNodes, info, path, result) {
   if (!isIterableObject(result)) {
-    throw new GraphQLError(`Expected Iterable, but did not find one for field "${info.parentTypeName}.${info.fieldName}".`);
+    throw new GraphQLError(
+      `Expected Iterable, but did not find one for field "${info.parentTypeName}.${info.fieldName}".`
+    );
   }
   let containsPromise = false;
   const completedResults = Array.from(result, (item, index) => {
@@ -273,20 +433,44 @@ function completeListValue(exeContext, returnTypeNode, fieldNodes, info, path, r
     try {
       let completedItem;
       if (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 (isPromise(completedItem)) {
         containsPromise = true;
         return completedItem.then(void 0, (rawError) => {
-          const error = locatedError(rawError, fieldNodes, pathToArray(itemPath));
+          const error = locatedError(
+            rawError,
+            fieldNodes,
+            pathToArray(itemPath)
+          );
           return handleFieldError(error, returnTypeNode, exeContext);
         });
       }
       return completedItem;
     } catch (rawError) {
-      const error = locatedError(rawError, fieldNodes, pathToArray(itemPath));
+      const error = locatedError(
+        rawError,
+        fieldNodes,
+        pathToArray(itemPath)
+      );
       return handleFieldError(error, returnTypeNode, exeContext);
     }
   });
@@ -295,7 +479,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 "${inspect(returnType)}" but received: ${inspect(result)}`);
+    throw new Error(
+      `Expected a value of type "${inspect(returnType)}" but received: ${inspect(result)}`
+    );
   }
   return serializedResult;
 }
@@ -305,19 +491,43 @@ function completeAbstractValue(exeContext, returnType, fieldNodes, info, path, r
   const contextValue = exeContext.contextValue;
   const runtimeTypeName = resolveTypeFn(result, contextValue, info);
   if (isPromise(runtimeTypeName)) {
-    return runtimeTypeName.then((resolvedRuntimeTypeName) => completeObjectValue(exeContext, ensureValidRuntimeType(resolvedRuntimeTypeName, 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);
+  return completeObjectValue(
+    exeContext,
+    ensureValidRuntimeType(runtimeTypeName, exeContext),
+    fieldNodes,
+    info,
+    path,
+    result
+  );
 }
 function ensureValidRuntimeType(runtimeTypeName, exeContext) {
   if (typeof runtimeTypeName !== "string") {
-    throw new GraphQLError(`Could not determine runtime type for abstract type ${runtimeTypeName}`);
+    throw new GraphQLError(
+      `Could not determine runtime type for abstract type ${runtimeTypeName}`
+    );
   }
   const runtimeType = exeContext.resolvers[runtimeTypeName];
   if (!runtimeType) {
-    throw new GraphQLError(`Type "${runtimeTypeName}" does not exist inside the schema.`);
+    throw new GraphQLError(
+      `Type "${runtimeTypeName}" does not exist inside the schema.`
+    );
   } else if (runtimeType instanceof GraphQLScalarType || runtimeType instanceof GraphQLEnumType || runtimeType instanceof GraphQLInputObjectType || runtimeType.__resolveType) {
-    throw new GraphQLError(`Given runtime object "${getRuntimeTypeInstanceName(runtimeType)}" type is not a possible type for "${runtimeTypeName}".`);
+    throw new GraphQLError(
+      `Given runtime object "${getRuntimeTypeInstanceName(
+        runtimeType
+      )}" type is not a possible type for "${runtimeTypeName}".`
+    );
   } else {
     return runtimeTypeName;
   }
@@ -338,7 +548,11 @@ 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 collectSubfields(exeContext, returnTypeName, fieldNodes) {
@@ -346,11 +560,103 @@ function collectSubfields(exeContext, returnTypeName, fieldNodes) {
   const visitedFragmentNames = /* @__PURE__ */ new Set();
   for (const node of fieldNodes) {
     if (node.selectionSet) {
-      subFieldNodes = collectFields(exeContext.resolvers, exeContext.fragments, exeContext.variableValues, returnTypeName, node.selectionSet, subFieldNodes, visitedFragmentNames);
+      subFieldNodes = 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 : inspect(originalError);
+  const error = new Error(`${prependMessage}: ${originalMessage}`);
+  return locatedError(error, void 0, pathToArray(path));
+}
 var defaultTypeResolver = function(value) {
   if (isObjectLike(value) && typeof value.__typename === "string") {
     return value.__typename;

package/lib/extractImplicitTypesRuntime.js

@@ -1,3 +1,4 @@
+"use strict";
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
@@ -57,7 +58,9 @@ function extractImplicitTypes(document, getTypeByName) {
         if (!implementedBy[node.name.value]) {
           implementedBy[node.name.value] = [];
         }
-        implementedBy[node.name.value].push(astNode.name.value);
+        implementedBy[node.name.value].push(
+          astNode.name.value
+        );
       });
       result[astNode.name.value] = {};
     }

package/lib/extractImplicitTypesRuntime.mjs

@@ -46,7 +46,9 @@ function extractImplicitTypes(document, getTypeByName) {
         if (!implementedBy[node.name.value]) {
           implementedBy[node.name.value] = [];
         }
-        implementedBy[node.name.value].push(astNode.name.value);
+        implementedBy[node.name.value].push(
+          astNode.name.value
+        );
       });
       result[astNode.name.value] = {};
     }

package/lib/hooks/types.d.ts

@@ -0,0 +1,33 @@
+import { ResolveInfo } from "../types";
+interface BaseExecuteHookArgs {
+    context: unknown;
+}
+interface BaseExecuteFieldHookArgs extends BaseExecuteHookArgs {
+    resolveInfo: ResolveInfo;
+}
+export interface BeforeFieldResolveHookArgs extends BaseExecuteFieldHookArgs {
+}
+export interface AfterFieldResolveHookArgs extends BaseExecuteFieldHookArgs {
+    result?: unknown;
+    error?: any;
+}
+export interface AfterFieldCompleteHookArgs extends BaseExecuteFieldHookArgs {
+    result?: unknown;
+    error?: any;
+}
+export interface BeforeFieldResolveHook {
+    (args: BeforeFieldResolveHookArgs): void;
+}
+export interface AfterFieldResolveHook {
+    (args: AfterFieldResolveHookArgs): void;
+}
+export interface AfterFieldCompleteHook {
+    (args: AfterFieldCompleteHookArgs): void;
+}
+export interface ExecutionHooks {
+    beforeFieldResolve?: BeforeFieldResolveHook;
+    afterFieldResolve?: AfterFieldResolveHook;
+    afterFieldComplete?: AfterFieldCompleteHook;
+}
+export {};
+//# sourceMappingURL=types.d.ts.map

package/lib/hooks/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/hooks/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAEvC,UAAU,mBAAmB;IAC3B,OAAO,EAAE,OAAO,CAAC;CAClB;AAED,UAAU,wBAAyB,SAAQ,mBAAmB;IAC5D,WAAW,EAAE,WAAW,CAAC;CAC1B;AAED,MAAM,WAAW,0BAA2B,SAAQ,wBAAwB;CAAG;AAE/E,MAAM,WAAW,yBAA0B,SAAQ,wBAAwB;IACzE,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,KAAK,CAAC,EAAE,GAAG,CAAC;CACb;AAED,MAAM,WAAW,0BAA2B,SAAQ,wBAAwB;IAC1E,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,KAAK,CAAC,EAAE,GAAG,CAAC;CACb;AAED,MAAM,WAAW,sBAAsB;IACrC,CAAC,IAAI,EAAE,0BAA0B,GAAG,IAAI,CAAC;CAC1C;AAED,MAAM,WAAW,qBAAqB;IACpC,CAAC,IAAI,EAAE,yBAAyB,GAAG,IAAI,CAAC;CACzC;AAED,MAAM,WAAW,sBAAsB;IACrC,CAAC,IAAI,EAAE,0BAA0B,GAAG,IAAI,CAAC;CAC1C;AAED,MAAM,WAAW,cAAc;IAC7B,kBAAkB,CAAC,EAAE,sBAAsB,CAAC;IAC5C,iBAAiB,CAAC,EAAE,qBAAqB,CAAC;IAC1C,kBAAkB,CAAC,EAAE,sBAAsB,CAAC;CAC7C"}

package/lib/hooks/types.js

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);

package/lib/index.d.ts

@@ -9,4 +9,5 @@ export { specifiedScalars } from "./values";
 export { annotateDocumentGraphQLTransform } from "./transforms/annotateDocumentGraphQLTransform";
 export type { PromiseOrValue } from "./jsutils/PromiseOrValue";
 export type { NameNode, DocumentNode, OperationDefinitionNode, VariableDefinitionNode, VariableNode, SelectionSetNode, FieldNode, ArgumentNode, FragmentSpreadNode, InlineFragmentNode, FragmentDefinitionNode, IntValueNode, FloatValueNode, StringValueNode, BooleanValueNode, NullValueNode, EnumValueNode, ListValueNode, ObjectValueNode, ObjectFieldNode, DirectiveNode, NamedTypeNode, ListTypeNode, NonNullTypeNode, SchemaDefinitionNode, OperationTypeDefinitionNode, ScalarTypeDefinitionNode, ObjectTypeDefinitionNode, FieldDefinitionNode, InputValueDefinitionNode, InterfaceTypeDefinitionNode, UnionTypeDefinitionNode, EnumTypeDefinitionNode, EnumValueDefinitionNode, InputObjectTypeDefinitionNode, DirectiveDefinitionNode, SchemaExtensionNode, ScalarTypeExtensionNode, ObjectTypeExtensionNode, InterfaceTypeExtensionNode, UnionTypeExtensionNode, EnumTypeExtensionNode, InputObjectTypeExtensionNode, } from "./ast/TypedAST";
+export { BeforeFieldResolveHookArgs, AfterFieldResolveHookArgs, AfterFieldCompleteHookArgs, BeforeFieldResolveHook, AfterFieldResolveHook, AfterFieldCompleteHook, ExecutionHooks, } from "./hooks/types";
 //# sourceMappingURL=index.d.ts.map