graphql-request

Variables

• batchRequests
• rawRequest

Functions

• analyzeDocument()
• gql()
• request()

Classes

• ClientError

  • request
  • response
• GraphQLClient

  • batchRequests()
  • rawRequest
  • request()
  • requestConfig
  • setEndpoint()
  • setHeader()
  • setHeaders()

Interfaces

• BatchRequestsExtendedOptions

  • url
• BatchRequestsOptions

  • documents
  • requestHeaders
  • signal
• GraphQLResponse

  • data
  • errors
  • extensions
  • status

Type Aliases

• BatchRequestDocument
• RawRequestOptions
• RequestDocument
• RequestExtendedOptions
• RequestInitExtended
• RequestMiddleware
• RequestOptions
• ResponseMiddleware
• Variables

variable batchRequests

const batchRequests: BatchRequests;

• Send a batch of GraphQL Document to the GraphQL server for execution.

  Example 1

  // You can pass a raw string
  
  await batchRequests('https://foo.bar/graphql', [
  {
   query: `
    {
      query {
        users
      }
    }`
  },
  {
    query: `
    {
      query {
        users
      }
    }`
  }])
  
  // You can also pass a GraphQL DocumentNode as query. Convenient if you
  // are using graphql-tag package.
  
  import gql from 'graphql-tag'
  
  await batchRequests('https://foo.bar/graphql', [{ query: gql`...` }])

variable rawRequest

const rawRequest: RawRequest;

• Send a GraphQL Query to the GraphQL server for execution.

function analyzeDocument

analyzeDocument: (
    document: RequestDocument,
    excludeOperationName?: boolean
) => { expression: string; operationName: string | undefined; isMutation: boolean };

function gql

gql: (chunks: TemplateStringsArray, ...variables: unknown[]) => string;

• Convenience passthrough template tag to get the benefits of tooling for the gql template tag. This does not actually parse the input into a GraphQL DocumentNode like graphql-tag package does. It just returns the string with any variables given interpolated. Can save you a bit of performance and having to install another package.

  Remarks

  Several tools in the Node GraphQL ecosystem are hardcoded to specially treat any template tag named "gql". For example see this prettier issue: https://github.com/prettier/prettier/issues/4360. Using this template tag has no runtime effect beyond variable interpolation.

  Example 1

  import { gql } from 'graphql-request'
  
  await request('https://foo.bar/graphql', gql`...`)

function request

request: {
    <T, V extends object = object>(
        options: RequestExtendedOptions<V, T>
    ): Promise<T>;
    <T, V extends object = object>(
        url: string,
        document: any,
        ...variablesAndRequestHeaders: VariablesAndRequestHeadersArgs<V>
    ): Promise<T>;
};

• Send a GraphQL Document to the GraphQL server for execution.

  Example 1

  // You can pass a raw string
  
  await request('https://foo.bar/graphql', `
    {
      query {
        users
      }
    }
  `)
  
  // You can also pass a GraphQL DocumentNode. Convenient if you
  // are using graphql-tag package.
  
  import gql from 'graphql-tag'
  
  await request('https://foo.bar/graphql', gql`...`)
  
  // If you don't actually care about using DocumentNode but just
  // want the tooling support for gql template tag like IDE syntax
  // coloring and prettier autoformat then note you can use the
  // passthrough gql tag shipped with graphql-request to save a bit
  // of performance and not have to install another dep into your project.
  
  import { gql } from 'graphql-request'
  
  await request('https://foo.bar/graphql', gql`...`)

type BatchRequestDocument

type BatchRequestDocument<V extends Variables = Variables> = {
    document: RequestDocument;
    variables?: V;
};

type RawRequestOptions

type RawRequestOptions<V extends Variables = Variables> = {
    query: string;
    requestHeaders?: HeadersInit;
    signal?: RequestInit['signal'];
} & (V extends Record<any, never>
    ? {
          variables?: V;
      }
    : keyof RemoveIndex<V> extends never
    ? {
          variables?: V;
      }
    : {
          variables: V;
      });

type RequestDocument

type RequestDocument = string | DocumentNode;

type RequestExtendedOptions

type RequestExtendedOptions<V extends Variables = Variables, T = unknown> = {
    url: string;
} & RequestOptions<V, T>;

type RequestInitExtended

type RequestInitExtended<V extends Variables = Variables> = RequestInit & {
    url: string;
    operationName?: string;
    variables?: V;
};

type RequestMiddleware

type RequestMiddleware<V extends Variables = Variables> = (
    request: RequestInitExtended<V>
) => RequestInitExtended | Promise<RequestInitExtended>;

type RequestOptions

type RequestOptions<V extends Variables = Variables, T = unknown> = {
    document: RequestDocument | TypedDocumentNode<T, V>;
    requestHeaders?: HeadersInit;
    signal?: RequestInit['signal'];
} & (V extends Record<any, never>
    ? {
          variables?: V;
      }
    : keyof RemoveIndex<V> extends never
    ? {
          variables?: V;
      }
    : {
          variables: V;
      });

type ResponseMiddleware

type ResponseMiddleware = (
    response: GraphQLClientResponse<unknown> | ClientError | Error,
    request: RequestInitExtended
) => MaybePromise<void>;

type Variables

type Variables = object;