graphql 14.4.2 → 14.5.3

package/README.md

@@ -11,7 +11,6 @@ https://graphql.org/graphql-js/.
 
 Looking for help? Find resources [from the community](https://graphql.org/community/).
 
-
 ## Getting Started
 
 An overview of GraphQL in general is available in the
@@ -47,7 +46,7 @@ import {
   graphql,
   GraphQLSchema,
   GraphQLObjectType,
-  GraphQLString
+  GraphQLString,
 } from 'graphql';
 
 var schema = new GraphQLSchema({
@@ -58,10 +57,10 @@ var schema = new GraphQLSchema({
         type: GraphQLString,
         resolve() {
           return 'world';
-        }
-      }
-    }
-  })
+        },
+      },
+    },
+  }),
 });
 ```
 
@@ -76,13 +75,11 @@ Then, serve the result of a query against that type schema.
 var query = '{ hello }';
 
 graphql(schema, query).then(result => {
-
   // Prints
   // {
   //   data: { hello: "world" }
   // }
   console.log(result);
-
 });
 ```
 
@@ -94,7 +91,6 @@ it, reporting errors otherwise.
 var query = '{ boyhowdy }';
 
 graphql(schema, query).then(result => {
-
   // Prints
   // {
   //   errors: [
@@ -103,7 +99,6 @@ graphql(schema, query).then(result => {
   //   ]
   // }
   console.log(result);
-
 });
 ```
 

package/error/GraphQLError.d.ts

@@ -0,0 +1,87 @@
+import Maybe from '../tsutils/Maybe';
+
+import { ASTNode } from '../language/ast';
+import { Source } from '../language/source';
+import { SourceLocation, getLocation } from '../language/location';
+
+/**
+ * A GraphQLError describes an Error found during the parse, validate, or
+ * execute phases of performing a GraphQL operation. In addition to a message
+ * and stack trace, it also includes information about the locations in a
+ * GraphQL document and/or execution result that correspond to the Error.
+ */
+export class GraphQLError extends Error {
+  constructor(
+    message: string,
+    nodes?: ReadonlyArray<ASTNode> | ASTNode | undefined,
+    source?: Maybe<Source>,
+    positions?: Maybe<ReadonlyArray<number>>,
+    path?: Maybe<ReadonlyArray<string | number>>,
+    originalError?: Maybe<Error>,
+    extensions?: Maybe<{ [key: string]: any }>,
+  );
+
+  /**
+   * A message describing the Error for debugging purposes.
+   *
+   * Enumerable, and appears in the result of JSON.stringify().
+   *
+   * Note: should be treated as readonly, despite invariant usage.
+   */
+  message: string;
+
+  /**
+   * An array of { line, column } locations within the source GraphQL document
+   * which correspond to this error.
+   *
+   * Errors during validation often contain multiple locations, for example to
+   * point out two things with the same name. Errors during execution include a
+   * single location, the field which produced the error.
+   *
+   * Enumerable, and appears in the result of JSON.stringify().
+   */
+  readonly locations: ReadonlyArray<SourceLocation> | undefined;
+
+  /**
+   * An array describing the JSON-path into the execution response which
+   * corresponds to this error. Only included for errors during execution.
+   *
+   * Enumerable, and appears in the result of JSON.stringify().
+   */
+  readonly path: ReadonlyArray<string | number> | undefined;
+
+  /**
+   * An array of GraphQL AST Nodes corresponding to this error.
+   */
+  readonly nodes: ReadonlyArray<ASTNode> | undefined;
+
+  /**
+   * The source GraphQL document corresponding to this error.
+   *
+   * Note that if this Error represents more than one node, the source may not
+   * represent nodes after the first node.
+   */
+  readonly source: Source | undefined;
+
+  /**
+   * An array of character offsets within the source GraphQL document
+   * which correspond to this error.
+   */
+  readonly positions: ReadonlyArray<number> | undefined;
+
+  /**
+   * The original error thrown from a field resolver during execution.
+   */
+  readonly originalError: Maybe<Error>;
+
+  /**
+   * Extension fields to add to the formatted error.
+   */
+  readonly extensions: { [key: string]: any } | undefined;
+}
+
+/**
+ * Prints a GraphQLError to a string, representing useful location information
+ * about the error's position in the source.
+ */
+export function printError(error: GraphQLError): string;

package/error/GraphQLError.js

@@ -158,55 +158,17 @@ function printError(error) {
   var output = error.message;
 
   if (error.nodes) {
-    var _iteratorNormalCompletion = true;
-    var _didIteratorError = false;
-    var _iteratorError = undefined;
+    for (var _i2 = 0, _error$nodes2 = error.nodes; _i2 < _error$nodes2.length; _i2++) {
+      var node = _error$nodes2[_i2];
 
-    try {
-      for (var _iterator = error.nodes[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
-        var node = _step.value;
-
-        if (node.loc) {
-          output += '\n\n' + (0, _printLocation.printLocation)(node.loc);
-        }
-      }
-    } catch (err) {
-      _didIteratorError = true;
-      _iteratorError = err;
-    } finally {
-      try {
-        if (!_iteratorNormalCompletion && _iterator.return != null) {
-          _iterator.return();
-        }
-      } finally {
-        if (_didIteratorError) {
-          throw _iteratorError;
-        }
+      if (node.loc) {
+        output += '\n\n' + (0, _printLocation.printLocation)(node.loc);
       }
     }
   } else if (error.source && error.locations) {
-    var _iteratorNormalCompletion2 = true;
-    var _didIteratorError2 = false;
-    var _iteratorError2 = undefined;
-
-    try {
-      for (var _iterator2 = error.locations[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
-        var location = _step2.value;
-        output += '\n\n' + (0, _printLocation.printSourceLocation)(error.source, location);
-      }
-    } catch (err) {
-      _didIteratorError2 = true;
-      _iteratorError2 = err;
-    } finally {
-      try {
-        if (!_iteratorNormalCompletion2 && _iterator2.return != null) {
-          _iterator2.return();
-        }
-      } finally {
-        if (_didIteratorError2) {
-          throw _iteratorError2;
-        }
-      }
+    for (var _i4 = 0, _error$locations2 = error.locations; _i4 < _error$locations2.length; _i4++) {
+      var location = _error$locations2[_i4];
+      output += '\n\n' + (0, _printLocation.printSourceLocation)(error.source, location);
     }
   }
 

package/error/GraphQLError.js.flow

@@ -1,6 +1,7 @@
 // @flow strict
 
 import isObjectLike from '../jsutils/isObjectLike';
+
 import { type ASTNode } from '../language/ast';
 import { type Source } from '../language/source';
 import { type SourceLocation, getLocation } from '../language/location';

package/error/GraphQLError.mjs

@@ -151,55 +151,17 @@ export function printError(error) {
   var output = error.message;
 
   if (error.nodes) {
-    var _iteratorNormalCompletion = true;
-    var _didIteratorError = false;
-    var _iteratorError = undefined;
+    for (var _i2 = 0, _error$nodes2 = error.nodes; _i2 < _error$nodes2.length; _i2++) {
+      var node = _error$nodes2[_i2];
 
-    try {
-      for (var _iterator = error.nodes[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
-        var node = _step.value;
-
-        if (node.loc) {
-          output += '\n\n' + printLocation(node.loc);
-        }
-      }
-    } catch (err) {
-      _didIteratorError = true;
-      _iteratorError = err;
-    } finally {
-      try {
-        if (!_iteratorNormalCompletion && _iterator.return != null) {
-          _iterator.return();
-        }
-      } finally {
-        if (_didIteratorError) {
-          throw _iteratorError;
-        }
+      if (node.loc) {
+        output += '\n\n' + printLocation(node.loc);
       }
     }
   } else if (error.source && error.locations) {
-    var _iteratorNormalCompletion2 = true;
-    var _didIteratorError2 = false;
-    var _iteratorError2 = undefined;
-
-    try {
-      for (var _iterator2 = error.locations[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
-        var location = _step2.value;
-        output += '\n\n' + printSourceLocation(error.source, location);
-      }
-    } catch (err) {
-      _didIteratorError2 = true;
-      _iteratorError2 = err;
-    } finally {
-      try {
-        if (!_iteratorNormalCompletion2 && _iterator2.return != null) {
-          _iterator2.return();
-        }
-      } finally {
-        if (_didIteratorError2) {
-          throw _iteratorError2;
-        }
-      }
+    for (var _i4 = 0, _error$locations2 = error.locations; _i4 < _error$locations2.length; _i4++) {
+      var location = _error$locations2[_i4];
+      output += '\n\n' + printSourceLocation(error.source, location);
     }
   }
 

package/error/formatError.d.ts

@@ -0,0 +1,39 @@
+import { SourceLocation } from '../language/location';
+import { GraphQLError } from './GraphQLError';
+
+/**
+ * Given a GraphQLError, format it according to the rules described by the
+ * Response Format, Errors section of the GraphQL Specification.
+ */
+export function formatError(error: GraphQLError): GraphQLFormattedError;
+
+/**
+ * @see https://github.com/graphql/graphql-spec/blob/master/spec/Section%207%20--%20Response.md#errors
+ */
+export interface GraphQLFormattedError<
+  TExtensions extends Record<string, any> = Record<string, any>
+> {
+  /**
+   * A short, human-readable summary of the problem that **SHOULD NOT** change
+   * from occurrence to occurrence of the problem, except for purposes of
+   * localization.
+   */
+  readonly message: string;
+  /**
+   * If an error can be associated to a particular point in the requested
+   * GraphQL document, it should contain a list of locations.
+   */
+  readonly locations?: ReadonlyArray<SourceLocation>;
+  /**
+   * If an error can be associated to a particular field in the GraphQL result,
+   * it _must_ contain an entry with the key `path` that details the path of
+   * the response field which experienced the error. This allows clients to
+   * identify whether a null result is intentional or caused by a runtime error.
+   */
+  readonly path?: ReadonlyArray<string | number>;
+  /**
+   * Reserved for implementors to extend the protocol however they see fit,
+   * and hence there are no additional restrictions on its contents.
+   */
+  readonly extensions?: TExtensions;
+}

package/error/formatError.js

@@ -5,7 +5,7 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.formatError = formatError;
 
-var _invariant = _interopRequireDefault(require("../jsutils/invariant"));
+var _devAssert = _interopRequireDefault(require("../jsutils/devAssert"));
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
@@ -14,7 +14,7 @@ function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { de
  * Response Format, Errors section of the GraphQL Specification.
  */
 function formatError(error) {
-  !error ? (0, _invariant.default)(0, 'Received null or undefined error.') : void 0;
+  error || (0, _devAssert.default)(0, 'Received null or undefined error.');
   var message = error.message || 'An unknown error occurred.';
   var locations = error.locations;
   var path = error.path;
@@ -30,3 +30,6 @@ function formatError(error) {
     path: path
   };
 }
+/**
+ * @see https://github.com/graphql/graphql-spec/blob/master/spec/Section%207%20--%20Response.md#errors
+ */

package/error/formatError.js.flow

@@ -1,15 +1,17 @@
 // @flow strict
 
-import invariant from '../jsutils/invariant';
-import { type GraphQLError } from './GraphQLError';
+import devAssert from '../jsutils/devAssert';
+
 import { type SourceLocation } from '../language/location';
 
+import { type GraphQLError } from './GraphQLError';
+
 /**
  * Given a GraphQLError, format it according to the rules described by the
  * Response Format, Errors section of the GraphQL Specification.
  */
 export function formatError(error: GraphQLError): GraphQLFormattedError {
-  invariant(error, 'Received null or undefined error.');
+  devAssert(error, 'Received null or undefined error.');
   const message = error.message || 'An unknown error occurred.';
   const locations = error.locations;
   const path = error.path;
@@ -20,9 +22,31 @@ export function formatError(error: GraphQLError): GraphQLFormattedError {
     : { message, locations, path };
 }
 
+/**
+ * @see https://github.com/graphql/graphql-spec/blob/master/spec/Section%207%20--%20Response.md#errors
+ */
 export type GraphQLFormattedError = {|
+  /**
+   * A short, human-readable summary of the problem that **SHOULD NOT** change
+   * from occurrence to occurrence of the problem, except for purposes of
+   * localization.
+   */
   +message: string,
+  /**
+   * If an error can be associated to a particular point in the requested
+   * GraphQL document, it should contain a list of locations.
+   */
   +locations: $ReadOnlyArray<SourceLocation> | void,
+  /**
+   * If an error can be associated to a particular field in the GraphQL result,
+   * it _must_ contain an entry with the key `path` that details the path of
+   * the response field which experienced the error. This allows clients to
+   * identify whether a null result is intentional or caused by a runtime error.
+   */
   +path: $ReadOnlyArray<string | number> | void,
+  /**
+   * Reserved for implementors to extend the protocol however they see fit,
+   * and hence there are no additional restrictions on its contents.
+   */
   +extensions?: { [key: string]: mixed, ... },
 |};

package/error/formatError.mjs

@@ -1,11 +1,11 @@
-import invariant from '../jsutils/invariant';
+import devAssert from '../jsutils/devAssert';
 
 /**
  * Given a GraphQLError, format it according to the rules described by the
  * Response Format, Errors section of the GraphQL Specification.
  */
 export function formatError(error) {
-  !error ? invariant(0, 'Received null or undefined error.') : void 0;
+  error || devAssert(0, 'Received null or undefined error.');
   var message = error.message || 'An unknown error occurred.';
   var locations = error.locations;
   var path = error.path;
@@ -21,3 +21,6 @@ export function formatError(error) {
     path: path
   };
 }
+/**
+ * @see https://github.com/graphql/graphql-spec/blob/master/spec/Section%207%20--%20Response.md#errors
+ */

package/error/index.d.ts

@@ -0,0 +1,4 @@
+export { GraphQLError, printError } from './GraphQLError';
+export { syntaxError } from './syntaxError';
+export { locatedError } from './locatedError';
+export { formatError, GraphQLFormattedError } from './formatError';

package/error/locatedError.d.ts

@@ -0,0 +1,13 @@
+import { ASTNode } from '../language/ast';
+import { GraphQLError } from './GraphQLError';
+
+/**
+ * Given an arbitrary Error, presumably thrown while attempting to execute a
+ * GraphQL operation, produce a new GraphQLError aware of the location in the
+ * document responsible for the original Error.
+ */
+export function locatedError(
+  originalError: Error | GraphQLError,
+  nodes: ReadonlyArray<ASTNode>,
+  path: ReadonlyArray<string | number>,
+): GraphQLError;

package/error/locatedError.js.flow

@@ -1,8 +1,9 @@
 // @flow strict
 
-import { GraphQLError } from './GraphQLError';
 import { type ASTNode } from '../language/ast';
 
+import { GraphQLError } from './GraphQLError';
+
 /**
  * Given an arbitrary Error, presumably thrown while attempting to execute a
  * GraphQL operation, produce a new GraphQLError aware of the location in the

package/error/locatedError.mjs

@@ -1,10 +1,10 @@
 import { GraphQLError } from './GraphQLError';
-
 /**
  * Given an arbitrary Error, presumably thrown while attempting to execute a
  * GraphQL operation, produce a new GraphQLError aware of the location in the
  * document responsible for the original Error.
  */
+
 export function locatedError(originalError, nodes, path) {
   // Note: this uses a brand-check to support GraphQL errors originating from
   // other contexts.

package/error/syntaxError.d.ts

@@ -0,0 +1,12 @@
+import { Source } from '../language/source';
+import { GraphQLError } from './GraphQLError';
+
+/**
+ * Produces a GraphQLError representing a syntax error, containing useful
+ * descriptive information about the syntax error's position in the source.
+ */
+export function syntaxError(
+  source: Source,
+  position: number,
+  description: string,
+): GraphQLError;

package/error/syntaxError.js.flow

@@ -1,6 +1,7 @@
 // @flow strict
 
 import { type Source } from '../language/source';
+
 import { GraphQLError } from './GraphQLError';
 
 /**

package/execution/execute.d.ts

@@ -0,0 +1,190 @@
+import Maybe from '../tsutils/Maybe';
+import { PromiseOrValue } from '../jsutils/PromiseOrValue';
+import { Path, addPath, pathToArray } from '../jsutils/Path';
+
+import { GraphQLError, locatedError } from '../error';
+import {
+  DirectiveNode,
+  DocumentNode,
+  OperationDefinitionNode,
+  SelectionSetNode,
+  FieldNode,
+  InlineFragmentNode,
+  FragmentDefinitionNode,
+} from '../language/ast';
+import { GraphQLSchema } from '../type/schema';
+import {
+  GraphQLField,
+  GraphQLFieldResolver,
+  GraphQLResolveInfo,
+  GraphQLTypeResolver,
+  GraphQLObjectType,
+} from '../type/definition';
+
+/**
+ * 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: { [key: string]: FragmentDefinitionNode };
+  rootValue: any;
+  contextValue: any;
+  operation: OperationDefinitionNode;
+  variableValues: { [key: string]: any };
+  fieldResolver: GraphQLFieldResolver<any, any>;
+  errors: GraphQLError[];
+}
+
+export interface ExecutionResultDataDefault {
+  [key: string]: any;
+}
+
+/**
+ * The result of GraphQL execution.
+ *
+ *   - `errors` is included when any errors occurred as a non-empty array.
+ *   - `data` is the result of a successful execution of the query.
+ */
+// TS_SPECIFIC: TData and ExecutionResultDataDefault
+export interface ExecutionResult<TData = ExecutionResultDataDefault> {
+  errors?: ReadonlyArray<GraphQLError>;
+  data?: TData | null;
+}
+
+export type ExecutionArgs = {
+  schema: GraphQLSchema;
+  document: DocumentNode;
+  rootValue?: any;
+  contextValue?: any;
+  variableValues?: Maybe<{ [key: string]: any }>;
+  operationName?: Maybe<string>;
+  fieldResolver?: Maybe<GraphQLFieldResolver<any, any>>;
+  typeResolver?: Maybe<GraphQLTypeResolver<any, any>>;
+};
+
+/**
+ * Implements the "Evaluating requests" section of the GraphQL specification.
+ *
+ * Returns either a synchronous ExecutionResult (if all encountered resolvers
+ * are synchronous), or a Promise of an ExecutionResult that will eventually be
+ * resolved and never rejected.
+ *
+ * If the arguments to this function do not result in a legal execution context,
+ * a GraphQLError will be thrown immediately explaining the invalid input.
+ *
+ * Accepts either an object with named arguments, or individual arguments.
+ */
+export function execute<TData = ExecutionResultDataDefault>(
+  args: ExecutionArgs,
+): PromiseOrValue<ExecutionResult<TData>>;
+export function execute<TData = ExecutionResultDataDefault>(
+  schema: GraphQLSchema,
+  document: DocumentNode,
+  rootValue?: any,
+  contextValue?: any,
+  variableValues?: Maybe<{ [key: string]: any }>,
+  operationName?: Maybe<string>,
+  fieldResolver?: Maybe<GraphQLFieldResolver<any, any>>,
+  typeResolver?: Maybe<GraphQLTypeResolver<any, any>>,
+): PromiseOrValue<ExecutionResult<TData>>;
+
+/**
+ * Essential assertions before executing to provide developer feedback for
+ * improper use of the GraphQL library.
+ */
+export function assertValidExecutionArguments(
+  schema: GraphQLSchema,
+  document: DocumentNode,
+  rawVariableValues: Maybe<{ [key: string]: any }>,
+): void;
+
+/**
+ * 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.
+ */
+export function buildExecutionContext(
+  schema: GraphQLSchema,
+  document: DocumentNode,
+  rootValue: any,
+  contextValue: any,
+  rawVariableValues: Maybe<{ [key: string]: any }>,
+  operationName: Maybe<string>,
+  fieldResolver: Maybe<GraphQLFieldResolver<any, any>>,
+  typeResolver?: Maybe<GraphQLTypeResolver<any, any>>,
+): ReadonlyArray<GraphQLError> | ExecutionContext;
+
+/**
+ * Given a selectionSet, adds all of the fields in that selection to
+ * the passed in map of fields, and returns it at the end.
+ *
+ * CollectFields requires the "runtime type" of an object. For a field which
+ * returns an Interface or Union type, the "runtime type" will be the actual
+ * Object type returned by that field.
+ */
+export function collectFields(
+  exeContext: ExecutionContext,
+  runtimeType: GraphQLObjectType,
+  selectionSet: SelectionSetNode,
+  fields: { [key: string]: Array<FieldNode> },
+  visitedFragmentNames: { [key: string]: boolean },
+): { [key: string]: Array<FieldNode> };
+
+export function buildResolveInfo(
+  exeContext: ExecutionContext,
+  fieldDef: GraphQLField<any, any>,
+  fieldNodes: ReadonlyArray<FieldNode>,
+  parentType: GraphQLObjectType,
+  path: Path,
+): GraphQLResolveInfo;
+
+// Isolates the "ReturnOrAbrupt" behavior to not de-opt the `resolveField`
+// function. Returns the result of resolveFn or the abrupt-return Error object.
+// TS_SPECIFIC: TSource
+export function resolveFieldValueOrError<TSource>(
+  exeContext: ExecutionContext,
+  fieldDef: GraphQLField<TSource, any>,
+  fieldNodes: ReadonlyArray<FieldNode>,
+  resolveFn: GraphQLFieldResolver<TSource, any>,
+  source: TSource,
+  info: GraphQLResolveInfo,
+): Error | any;
+
+/**
+ * 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<any, any>;
+
+/**
+ * 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.
+ */
+export const defaultFieldResolver: GraphQLFieldResolver<any, any>;
+
+/**
+ * This method looks up the field on the given type defintion.
+ * It has special casing for the two introspection fields, __schema
+ * and __typename. __typename is special because it can always be
+ * queried as a field, even in situations where no other fields
+ * are allowed, like on a Union. __schema could get automatically
+ * added to the query type, but that would require mutating type
+ * definitions, which would cause issues.
+ */
+export function getFieldDef(
+  schema: GraphQLSchema,
+  parentType: GraphQLObjectType,
+  fieldName: string,
+): Maybe<GraphQLField<any, any>>;