• Version 0.10.2
  • Published
  • 45.6 kB
  • No dependencies
  • MIT license


npm i graphql-relay
yarn add graphql-relay
pnpm add graphql-relay


A library to help construct a graphql-js server supporting react-relay.



variable backwardConnectionArgs

const backwardConnectionArgs: GraphQLFieldConfigArgumentMap;
  • Returns a GraphQLFieldConfigArgumentMap appropriate to include on a field whose return type is a connection type with backward pagination.

variable connectionArgs

const connectionArgs: GraphQLFieldConfigArgumentMap;
  • Returns a GraphQLFieldConfigArgumentMap appropriate to include on a field whose return type is a connection type with bidirectional pagination.

variable forwardConnectionArgs

const forwardConnectionArgs: GraphQLFieldConfigArgumentMap;
  • Returns a GraphQLFieldConfigArgumentMap appropriate to include on a field whose return type is a connection type with forward pagination.


function connectionDefinitions

connectionDefinitions: (
config: ConnectionConfig
) => GraphQLConnectionDefinitions;
  • Returns a GraphQLObjectType for a connection with the given name, and whose nodes are of the specified type.

function connectionFromArray

connectionFromArray: <T>(
data: ReadonlyArray<T>,
args: ConnectionArguments
) => Connection<T>;
  • A simple function that accepts an array and connection arguments, and returns a connection object for use in GraphQL. It uses array offsets as pagination, so pagination will only work if the array is static.

function connectionFromArraySlice

connectionFromArraySlice: <T>(
arraySlice: ReadonlyArray<T>,
args: ConnectionArguments,
meta: ArraySliceMetaInfo
) => Connection<T>;
  • Given a slice (subset) of an array, returns a connection object for use in GraphQL.

    This function is similar to connectionFromArray, but is intended for use cases where you know the cardinality of the connection, consider it too large to materialize the entire array, and instead wish pass in a slice of the total result large enough to cover the range specified in args.

function connectionFromPromisedArray

connectionFromPromisedArray: <T>(
dataPromise: Promise<ReadonlyArray<T>>,
args: ConnectionArguments
) => Promise<Connection<T>>;
  • A version of connectionFromArray that takes a promised array, and returns a promised connection.

function connectionFromPromisedArraySlice

connectionFromPromisedArraySlice: <T>(
dataPromise: Promise<ReadonlyArray<T>>,
args: ConnectionArguments,
arrayInfo: ArraySliceMetaInfo
) => Promise<Connection<T>>;
  • A version of connectionFromArraySlice that takes a promised array slice, and returns a promised connection.

function cursorForObjectInConnection

cursorForObjectInConnection: <T>(
data: ReadonlyArray<T>,
object: T
) => ConnectionCursor | null;
  • Return the cursor associated with an object in an array.

function cursorToOffset

cursorToOffset: (cursor: ConnectionCursor) => number;
  • Extracts the offset from the cursor string.

function fromGlobalId

fromGlobalId: (globalId: string) => ResolvedGlobalId;
  • Takes the "global ID" created by toGlobalID, and returns the type name and ID used to create it.

function getOffsetWithDefault

getOffsetWithDefault: (
cursor: ConnectionCursor | null | undefined,
defaultOffset: number
) => number;
  • Given an optional cursor and a default offset, returns the offset to use; if the cursor contains a valid offset, that will be used, otherwise it will be the default.

function globalIdField

globalIdField: <TContext>(
typeName?: string,
idFetcher?: (
obj: any,
context: TContext,
info: GraphQLResolveInfo
) => string | number
) => GraphQLFieldConfig<any, TContext>;
  • Creates the configuration for an id field on a node, using toGlobalId to construct the ID from the provided typename. The type-specific ID is fetched by calling idFetcher on the object, or if not provided, by accessing the id property on the object.

function mutationWithClientMutationId

mutationWithClientMutationId: <TInput = any, TOutput = unknown, TContext = any>(
config: MutationConfig<TInput, TOutput, TContext>
) => GraphQLFieldConfig<unknown, TContext>;
  • Returns a GraphQLFieldConfig for the mutation described by the provided MutationConfig.

function nodeDefinitions

nodeDefinitions: <TContext>(
fetchById: (id: string, context: TContext, info: GraphQLResolveInfo) => unknown,
typeResolver?: GraphQLTypeResolver<any, TContext>
) => GraphQLNodeDefinitions<TContext>;
  • Given a function to map from an ID to an underlying object, and a function to map from an underlying object to the concrete GraphQLObjectType it corresponds to, constructs a Node interface that objects can implement, and a field config for a node root field.

    If the typeResolver is omitted, object resolution on the interface will be handled with the isTypeOf method on object types, as with any GraphQL interface without a provided resolveType method.

function offsetToCursor

offsetToCursor: (offset: number) => ConnectionCursor;
  • Creates the cursor string from an offset.

function pluralIdentifyingRootField

pluralIdentifyingRootField: (
config: PluralIdentifyingRootFieldConfig
) => GraphQLFieldConfig<unknown, unknown>;

    function toGlobalId

    toGlobalId: (type: string, id: string | number) => string;
    • Takes a type name and an ID specific to that type name, and returns a "global ID" that is unique among all types.


    interface Connection

    interface Connection<T> {}
    • A type designed to be exposed as a Connection over GraphQL.

    property edges

    edges: Array<Edge<T>>;

      property pageInfo

      pageInfo: PageInfo;

        interface ConnectionArguments

        interface ConnectionArguments {}
        • A type describing the arguments a connection field receives in GraphQL.

        property after

        after?: ConnectionCursor | null;

          property before

          before?: ConnectionCursor | null;

            property first

            first?: number | null;

              property last

              last?: number | null;

                interface ConnectionConfig

                interface ConnectionConfig {}

                  property connectionFields

                  connectionFields?: ThunkObjMap<GraphQLFieldConfig<any, any>>;

                    property edgeFields

                    edgeFields?: ThunkObjMap<GraphQLFieldConfig<any, any>>;

                      property name

                      name?: string;

                        property nodeType

                        nodeType: GraphQLNamedOutputType | GraphQLNonNull<GraphQLNamedOutputType>;

                          property resolveCursor

                          resolveCursor?: GraphQLFieldResolver<any, any>;

                            property resolveNode

                            resolveNode?: GraphQLFieldResolver<any, any>;

                              interface Edge

                              interface Edge<T> {}
                              • A type designed to be exposed as a Edge over GraphQL.

                              property cursor

                              cursor: ConnectionCursor;

                                property node

                                node: T;

                                  interface GraphQLConnectionDefinitions

                                  interface GraphQLConnectionDefinitions {}

                                    property connectionType

                                    connectionType: GraphQLObjectType;

                                      property edgeType

                                      edgeType: GraphQLObjectType;

                                        interface PageInfo

                                        interface PageInfo {}
                                        • A type designed to be exposed as PageInfo over GraphQL.

                                        property endCursor

                                        endCursor: ConnectionCursor | null;

                                          property hasNextPage

                                          hasNextPage: boolean;

                                            property hasPreviousPage

                                            hasPreviousPage: boolean;

                                              property startCursor

                                              startCursor: ConnectionCursor | null;

                                                Type Aliases

                                                type ConnectionCursor

                                                type ConnectionCursor = string;
                                                • A type alias for cursors in this implementation.

                                                Package Files (6)

                                                Dependencies (0)

                                                No dependencies.

                                                Dev Dependencies (0)

                                                No dev dependencies.

                                                Peer Dependencies (1)


                                                To add a badge like this badgeto your package's README, use the codes available below.

                                                You may also use to create a custom badge linking to

                                                • Markdown
                                                • HTML
                                                  <a href=""><img src="" alt=""></a>