refactor: move ExecutionContext to new file

Author: yaacovCR

src/execution/compiledDocument.ts

@@ -0,0 +1,210 @@
+import { isObjectLike } from '../jsutils/isObjectLike';
+import { isPromise } from '../jsutils/isPromise';
+import type { ObjMap } from '../jsutils/ObjMap';
+
+import { GraphQLError } from '../error/GraphQLError';
+
+import type {
+  FragmentDefinitionNode,
+  OperationDefinitionNode,
+} from '../language/ast';
+import { Kind } from '../language/kinds';
+
+import type {
+  GraphQLFieldResolver,
+  GraphQLTypeResolver,
+} from '../type/definition';
+import type { GraphQLSchema } from '../type/schema';
+import { assertValidSchema } from '../type/validate';
+
+import type { ExecutionArgs } from './execute';
+import { getVariableValues } from './values';
+
+// This file contains a lot of such errors but we plan to refactor it anyway
+// so just disable it for entire file.
+
+/**
+ * Data that must be available at all points during query execution.
+ *
+ * Namely, schema of the type system that is currently executing,
+ * and the fragments defined in the query document
+ */
+export interface ExecutionContext {
+  schema: GraphQLSchema;
+  fragments: ObjMap<FragmentDefinitionNode>;
+  rootValue: unknown;
+  contextValue: unknown;
+  operation: OperationDefinitionNode;
+  variableValues: { [variable: string]: unknown };
+  fieldResolver: GraphQLFieldResolver<any, any>;
+  typeResolver: GraphQLTypeResolver<any, any>;
+  subscribeFieldResolver: GraphQLFieldResolver<any, any>;
+  errors: Array<GraphQLError>;
+}
+
+/**
+ * Constructs a ExecutionContext object from the arguments passed to
+ * execute, which we will pass throughout the other execution methods.
+ *
+ * Throws a GraphQLError if a valid execution context cannot be created.
+ *
+ * TODO: consider no longer exporting this function
+ * @internal
+ */
+export function buildExecutionContext(
+  args: ExecutionArgs,
+): ReadonlyArray<GraphQLError> | ExecutionContext {
+  const {
+    schema,
+    document,
+    rootValue,
+    contextValue,
+    variableValues: rawVariableValues,
+    operationName,
+    fieldResolver,
+    typeResolver,
+    subscribeFieldResolver,
+  } = args;
+
+  // If the schema used for execution is invalid, throw an error.
+  assertValidSchema(schema);
+
+  let operation: OperationDefinitionNode | undefined;
+  const fragments: ObjMap<FragmentDefinitionNode> = Object.create(null);
+  for (const definition of document.definitions) {
+    switch (definition.kind) {
+      case Kind.OPERATION_DEFINITION:
+        if (operationName == null) {
+          if (operation !== undefined) {
+            return [
+              new GraphQLError(
+                'Must provide operation name if query contains multiple operations.',
+              ),
+            ];
+          }
+          operation = definition;
+        } else if (definition.name?.value === operationName) {
+          operation = definition;
+        }
+        break;
+      case Kind.FRAGMENT_DEFINITION:
+        fragments[definition.name.value] = definition;
+        break;
+      default:
+      // ignore non-executable definitions
+    }
+  }
+
+  if (!operation) {
+    if (operationName != null) {
+      return [new GraphQLError(`Unknown operation named "${operationName}".`)];
+    }
+    return [new GraphQLError('Must provide an operation.')];
+  }
+
+  // FIXME: https://github.com/graphql/graphql-js/issues/2203
+  /* c8 ignore next */
+  const variableDefinitions = operation.variableDefinitions ?? [];
+
+  const coercedVariableValues = getVariableValues(
+    schema,
+    variableDefinitions,
+    rawVariableValues ?? {},
+    { maxErrors: 50 },
+  );
+
+  if (coercedVariableValues.errors) {
+    return coercedVariableValues.errors;
+  }
+
+  return {
+    schema,
+    fragments,
+    rootValue,
+    contextValue,
+    operation,
+    variableValues: coercedVariableValues.coerced,
+    fieldResolver: fieldResolver ?? defaultFieldResolver,
+    typeResolver: typeResolver ?? defaultTypeResolver,
+    subscribeFieldResolver: subscribeFieldResolver ?? defaultFieldResolver,
+    errors: [],
+  };
+}
+
+/**
+ * @internal
+ */
+export function buildPerEventExecutionContext(
+  exeContext: ExecutionContext,
+  payload: unknown,
+): ExecutionContext {
+  return {
+    ...exeContext,
+    rootValue: payload,
+    errors: [],
+  };
+}
+
+/**
+ * If a resolveType function is not given, then a default resolve behavior is
+ * used which attempts two strategies:
+ *
+ * First, See if the provided value has a `__typename` field defined, if so, use
+ * that value as name of the resolved type.
+ *
+ * Otherwise, test each possible type for the abstract type by calling
+ * isTypeOf for the object being coerced, returning the first type that matches.
+ */
+export const defaultTypeResolver: GraphQLTypeResolver<unknown, unknown> =
+  function (value, contextValue, info, abstractType) {
+    // First, look for `__typename`.
+    if (isObjectLike(value) && typeof value.__typename === 'string') {
+      return value.__typename;
+    }
+
+    // Otherwise, test each possible type.
+    const possibleTypes = info.schema.getPossibleTypes(abstractType);
+    const promisedIsTypeOfResults = [];
+
+    for (let i = 0; i < possibleTypes.length; i++) {
+      const type = possibleTypes[i];
+
+      if (type.isTypeOf) {
+        const isTypeOfResult = type.isTypeOf(value, contextValue, info);
+
+        if (isPromise(isTypeOfResult)) {
+          promisedIsTypeOfResults[i] = isTypeOfResult;
+        } else if (isTypeOfResult) {
+          return type.name;
+        }
+      }
+    }
+
+    if (promisedIsTypeOfResults.length) {
+      return Promise.all(promisedIsTypeOfResults).then((isTypeOfResults) => {
+        for (let i = 0; i < isTypeOfResults.length; i++) {
+          if (isTypeOfResults[i]) {
+            return possibleTypes[i].name;
+          }
+        }
+      });
+    }
+  };
+
+/**
+ * If a resolve function is not given, then a default resolve behavior is used
+ * which takes the property of the source object of the same name as the field
+ * and returns it as the result, or if it's a function, returns the result
+ * of calling that function while passing along args and context value.
+ */
+export const defaultFieldResolver: GraphQLFieldResolver<unknown, unknown> =
+  function (source: any, args, contextValue, info) {
+    // ensure source is a value for which property access is acceptable.
+    if (isObjectLike(source) || typeof source === 'function') {
+      const property = source[info.fieldName];
+      if (typeof property === 'function') {
+        return source[info.fieldName](args, contextValue, info);
+      }
+      return property;
+    }
+  };