Skip to content

Latest commit

 

History

History
225 lines (150 loc) · 9.33 KB

graphql-transport-ws.md

File metadata and controls

225 lines (150 loc) · 9.33 KB
Raw

GraphQL over WebSocket Protocol

Nomenclature

  • Socket is the main WebSocket communication channel between the server and the client
  • Connection is a connection within the established socket describing a "connection" through which the operation requests will be communicated

Communication

The WebSocket sub-protocol for this specification is: graphql-transport-ws.

Messages are represented through the JSON structure and are stringified before being sent over the network. They are bidirectional, meaning both the server and the client must conform to the specified message structure.

All messages contain the type field outlining the action this message describes. Depending on the type, the message can contain two more optional fields:

  • id used for uniquely identifying server responses and connecting them with the client's requests
  • payload holding the extra "payload" information to go with the specific message type

The server can close the socket (kick the client off) at any time. The close event dispatched by the server is used to describe the fatal error to the client.

The client closes the socket and the connection by dispatching a 1000: Normal Closure close event to the server indicating a normal closure.

Message types

ConnectionInit

Direction: Client -> Server

Indicates that the client wants to establish a connection within the existing socket. This connection is not the actual WebSocket communication channel, but is rather a frame within it asking the server to allow future operation requests.

The server must receive the connection initialisation message within the allowed waiting time specified in the connectionInitWaitTimeout parameter during the server setup. If the client does not request a connection within the allowed timeout, the server will close the socket with the event: 4408: Connection initialisation timeout.

If the server receives more than one ConnectionInit message at any given time, the server will close the socket with the event 4429: Too many initialisation requests.

interface ConnectionInitMessage {
  type: 'connection_init';
  payload?: Record<string, unknown>;
}

ConnectionAck

Direction: Server -> Client

Expected response to the ConnectionInit message from the client acknowledging a successful connection with the server.

The server can use the optional payload field to transfer additional details about the connection.

interface ConnectionAckMessage {
  type: 'connection_ack';
  payload?: Record<string, unknown>;
}

The client is now ready to request subscription operations.

Ping

Direction: bidirectional

Useful for detecting failed connections, displaying latency metrics or other types of network probing.

A Pong must be sent in response from the receiving party as soon as possible.

The Ping message can be sent at any time within the established socket.

The optional payload field can be used to transfer additional details about the ping.

interface PingMessage {
  type: 'ping';
  payload?: Record<string, unknown>;
}

Pong

Direction: bidirectional

The response to the Ping message. Must be sent as soon as the Ping message is received.

The Pong message can be sent at any time within the established socket. Furthermore, the Pong message may even be sent unsolicited as an unidirectional heartbeat.

The optional payload field can be used to transfer additional details about the pong.

interface PongMessage {
  type: 'pong';
  payload?: Record<string, unknown>;
}

Subscribe

Direction: Client -> Server

Requests an operation specified in the message payload. This message provides a unique ID field to connect published messages to the operation requested by this message.

If there is already an active subscriber for an operation matching the provided ID, regardless of the operation type, the server must close the socket immediately with the event 4409: Subscriber for <unique-operation-id> already exists.

interface SubscribeMessage {
  id: '<unique-operation-id>';
  type: 'subscribe';
  payload: {
    operationName?: string | null;
    query: string;
    variables?: Record<string, unknown> | null;
    extensions?: Record<string, unknown> | null;
  };
}

Executing operations is allowed only after the server has acknowledged the connection through the ConnectionAck message, if the connection is not acknowledged, the socket will be closed immediately with the event 4401: Unauthorized.

Next

Direction: Server -> Client

Operation execution result(s) from the source stream created by the binding Subscribe message. After all results have been emitted, the Complete message will follow indicating stream completion.

import { ExecutionResult } from 'graphql';

interface NextMessage {
  id: '<unique-operation-id>';
  type: 'next';
  payload: ExecutionResult;
}

Error

Direction: Server -> Client

Operation execution error(s) triggered by the Next message happening before the actual execution, usually due to validation errors.

import { GraphQLError } from 'graphql';

interface ErrorMessage {
  id: '<unique-operation-id>';
  type: 'error';
  payload: GraphQLError[];
}

Complete

Direction: bidirectional

  • Server -> Client indicates that the requested operation execution has completed. If the server dispatched the Error message relative to the original Subscribe message, no Complete message will be emitted.

  • Client -> Server indicates that the client has stopped listening and wants to complete the subscription. No further events, relevant to the original subscription, should be sent through. Even if the client completed a single result operation before it resolved, the result should not be sent through once it does.

interface CompleteMessage {
  id: '<unique-operation-id>';
  type: 'complete';
}

Invalid message

Direction: bidirectional

Receiving a message of a type or format which is not specified in this document will result in an immediate socket closure with the event 4400: <error-message>. The <error-message> can be vaguely descriptive on why the received message is invalid.

Examples

For the sake of clarity, the following examples demonstrate the communication protocol.

Successful connection initialisation

  1. Client sends a WebSocket handshake request with the sub-protocol: graphql-transport-ws
  2. Server accepts the handshake and establishes a WebSocket communication channel (which we call "socket")
  3. Client immediately dispatches a ConnectionInit message optionally providing a payload as agreed with the server
  4. Server validates the connection initialisation request and dispatches a ConnectionAck message to the client on successful connection
  5. Client has received the acknowledgement message and is now ready to request operation executions

Connection initialisation timeout

  1. Client sends a WebSocket handshake request with the sub-protocol: graphql-transport-ws
  2. Server accepts the handshake and establishes a WebSocket communication channel (which we call "socket")
  3. Client does not dispatch a ConnectionInit message
  4. Server waits for the ConnectionInit message for the duration specified in the connectionInitWaitTimeout parameter
  5. Server waiting time has passed
  6. Server closes the socket by dispatching the event 4408: Connection initialisation timeout

Single result operation

query and mutation operations without streaming directives

The client and the server has already gone through successful connection initialisation.

  1. Client generates a unique ID for the following operation
  2. Client dispatches the Subscribe message with the generated ID through the id field and the requested operation passed through the payload field
    All future communication is linked through this unique ID
  3. Server executes the single result GraphQL operation
  4. Server dispatches the result with the Next message
  5. Server dispatches the Complete message indicating that the execution has completed

Streaming operation

subscription operation and queries with streaming directives

The client and the server has already gone through successful connection initialisation.

  1. Client generates a unique ID for the following operation

  2. Client dispatches the Subscribe message with the generated ID through the id field and the requested operation passed through the payload field
    All future communication is linked through this unique ID

  3. Server executes the streaming GraphQL operation

  4. Server checks if the generated ID is unique across active streaming subscriptions

    • If not unique, the server will close the socket with the event 4409: Subscriber for <generated-id> already exists
    • If unique, continue...

  5. Server dispatches results over time with the Next message

    • Client stops the subscription by dispatching a Complete message
    • Server completes the source stream
      or
    • Server dispatches the Complete message indicating that the source stream has completed
    • Client completes the stream observer