transport

Documentation

Index

• func AddSubscriptionError(ctx context.Context, err *gqlerror.Error)
• func AppendCloseReason(ctx context.Context, reason string) context.Context
• func SendError(w http.ResponseWriter, code int, errors ...*gqlerror.Error)
• func SendErrorf(w http.ResponseWriter, code int, format string, args ...any)
• type GET
  • func (h GET) Do(w http.ResponseWriter, r *http.Request, exec graphql.GraphExecutor)
  • func (h GET) Supports(r *http.Request) bool
• type GRAPHQL
  • func (h GRAPHQL) Do(w http.ResponseWriter, r *http.Request, exec graphql.GraphExecutor)
  • func (h GRAPHQL) Supports(r *http.Request) bool
• type InitPayload
  • func GetInitPayload(ctx context.Context) InitPayload
  • func (p InitPayload) Authorization() string
  • func (p InitPayload) GetString(key string) string
• type MultipartForm
  • func (f MultipartForm) Do(w http.ResponseWriter, r *http.Request, exec graphql.GraphExecutor)
  • func (f MultipartForm) Supports(r *http.Request) bool
• type MultipartMixed
  • func (t MultipartMixed) Do(w http.ResponseWriter, r *http.Request, exec graphql.GraphExecutor)
  • func (t MultipartMixed) Supports(r *http.Request) bool
• type Options
  • func (o Options) Do(w http.ResponseWriter, r *http.Request, exec graphql.GraphExecutor)
  • func (o Options) Supports(r *http.Request) bool
• type POST
  • func (h POST) Do(w http.ResponseWriter, r *http.Request, exec graphql.GraphExecutor)
  • func (h POST) Supports(r *http.Request) bool
• type SSE
  • func (t SSE) Do(w http.ResponseWriter, r *http.Request, exec graphql.GraphExecutor)
  • func (t SSE) Supports(r *http.Request) bool
• type UrlEncodedForm
  • func (h UrlEncodedForm) Do(w http.ResponseWriter, r *http.Request, exec graphql.GraphExecutor)
  • func (h UrlEncodedForm) Supports(r *http.Request) bool
• type Websocket
  • func (t Websocket) Do(w http.ResponseWriter, r *http.Request, exec graphql.GraphExecutor)
  • func (t Websocket) Supports(r *http.Request) bool
• type WebsocketCloseFunc
• type WebsocketError
  • func (e WebsocketError) Error() string
• type WebsocketErrorFunc
• type WebsocketInitFunc

Functions

func AddSubscriptionError

func AddSubscriptionError(ctx context.Context, err *gqlerror.Error)

AddSubscriptionError is used to let websocket return an error message after subscription resolver returns a channel. for example:

func (r *subscriptionResolver) Method(ctx context.Context) (<-chan *model.Message, error) {
	ch := make(chan *model.Message)
	go func() {
     defer func() {
			close(ch)
     }
		// some kind of block processing (e.g.: gRPC client streaming)
		stream, err := gRPCClientStreamRequest(ctx)
		if err != nil {
			   transport.AddSubscriptionError(ctx, err)
            return // must return and close channel so websocket can send error back
     }
		for {
			m, err := stream.Recv()
			if err == io.EOF {
				return
			}
			if err != nil {
			   transport.AddSubscriptionError(ctx, err)
            return // must return and close channel so websocket can send error back
			}
			ch <- m
		}
	}()

	return ch, nil
}

see https://github.com/99designs/gqlgen/pull/2506 for more details

func AppendCloseReason

func AppendCloseReason(ctx context.Context, reason string) context.Context

func SendError

func SendError(w http.ResponseWriter, code int, errors ...*gqlerror.Error)

SendError sends a best effort error to a raw response writer. It assumes the client can understand the standard json error response

func SendErrorf

func SendErrorf(w http.ResponseWriter, code int, format string, args ...any)

SendErrorf wraps SendError to add formatted messages

Types

type GET

type GET struct {
	// Map of all headers that are added to graphql response. If not
	// set, only one header: Content-Type: application/graphql-response+json will be set.
	ResponseHeaders map[string][]string
	// UseGrapQLResponseJsonByDefault determines whether to use 'application/graphql-response+json'
	// as the response content type
	// when the Accept header is empty or 'application/*' or '*/*'.
	UseGrapQLResponseJsonByDefault bool
}

GET implements the GET side of the default HTTP transport defined in https://github.com/APIs-guru/graphql-over-http#get

func (GET) Do

func (h GET) Do(w http.ResponseWriter, r *http.Request, exec graphql.GraphExecutor)

func (GET) Supports

func (h GET) Supports(r *http.Request) bool

type GRAPHQL

type GRAPHQL struct {
	// Map of all headers that are added to graphql response. If not
	// set, only one header: Content-Type: application/json will be set.
	ResponseHeaders map[string][]string
}

GRAPHQL implements the application/graphql side of the HTTP transport see: https://graphql.org/learn/serving-over-http/#post-request If the "application/graphql" Content-Type header is present, treat the HTTP POST body contents as the GraphQL query string.

func (GRAPHQL) Do

func (h GRAPHQL) Do(w http.ResponseWriter, r *http.Request, exec graphql.GraphExecutor)

func (GRAPHQL) Supports

func (h GRAPHQL) Supports(r *http.Request) bool

type InitPayload

type InitPayload map[string]any

InitPayload is a structure that is parsed from the websocket init message payload. TO use request headers for non-websocket, instead wrap the graphql handler in a middleware.

func GetInitPayload

func GetInitPayload(ctx context.Context) InitPayload

GetInitPayload gets a map of the data sent with the connection_init message, which is used by graphql clients as a stand-in for HTTP headers.

func (InitPayload) Authorization

func (p InitPayload) Authorization() string

Authorization is a short hand for getting the Authorization header from the payload.

func (InitPayload) GetString

func (p InitPayload) GetString(key string) string

GetString safely gets a string value from the payload. It returns an empty string if the payload is nil or the value isn't set.

type MultipartForm

type MultipartForm struct {
	// MaxUploadSize sets the maximum number of bytes used to parse a request body
	// as multipart/form-data.
	MaxUploadSize int64

	// MaxMemory defines the maximum number of bytes used to parse a request body
	// as multipart/form-data in memory, with the remainder stored on disk in
	// temporary files.
	MaxMemory int64

	// Map of all headers that are added to graphql response. If not
	// set, only one header: Content-Type: application/json will be set.
	ResponseHeaders map[string][]string
}

MultipartForm the Multipart request spec https://github.com/jaydenseric/graphql-multipart-request-spec

func (MultipartForm) Do

func (f MultipartForm) Do(w http.ResponseWriter, r *http.Request, exec graphql.GraphExecutor)

func (MultipartForm) Supports

func (f MultipartForm) Supports(r *http.Request) bool

type MultipartMixed

type MultipartMixed struct {
	Boundary        string
	DeliveryTimeout time.Duration
}

MultipartMixed is a transport that supports the multipart/mixed spec

func (MultipartMixed) Do

func (t MultipartMixed) Do(w http.ResponseWriter, r *http.Request, exec graphql.GraphExecutor)

Do implements the multipart/mixed spec as a multipart/mixed response

func (MultipartMixed) Supports

func (t MultipartMixed) Supports(r *http.Request) bool

Supports checks if the request supports the multipart/mixed spec Might be worth check the spec required, but Apollo Client mislabel the spec in the headers.

type Options

type Options struct {
	// AllowedMethods is a list of allowed HTTP methods.
	AllowedMethods []string
}

Options responds to http OPTIONS and HEAD requests

func (Options) Do

func (o Options) Do(w http.ResponseWriter, r *http.Request, exec graphql.GraphExecutor)

func (Options) Supports

func (o Options) Supports(r *http.Request) bool

type POST

type POST struct {
	// Map of all headers that are added to graphql response. If not
	// set, only one header: Content-Type: application/graphql-response+json will be set.
	ResponseHeaders map[string][]string

	// UseGrapQLResponseJsonByDefault determines whether to use 'application/graphql-response+json'
	// as the response content type
	// when the Accept header is empty or 'application/*' or '*/*'.
	UseGrapQLResponseJsonByDefault bool
}

POST implements the POST side of the default HTTP transport defined in https://github.com/APIs-guru/graphql-over-http#post

func (POST) Do

func (h POST) Do(w http.ResponseWriter, r *http.Request, exec graphql.GraphExecutor)

func (POST) Supports

func (h POST) Supports(r *http.Request) bool

type SSE

type SSE struct {
	KeepAlivePingInterval time.Duration
}

func (SSE) Do

func (t SSE) Do(w http.ResponseWriter, r *http.Request, exec graphql.GraphExecutor)

func (SSE) Supports

func (t SSE) Supports(r *http.Request) bool

type UrlEncodedForm

type UrlEncodedForm struct {
	// Map of all headers that are added to graphql response. If not
	// set, only one header: Content-Type: application/json will be set.
	ResponseHeaders map[string][]string
}

FORM implements the application/x-www-form-urlencoded side of the default HTTP transport

func (UrlEncodedForm) Do

func (h UrlEncodedForm) Do(w http.ResponseWriter, r *http.Request, exec graphql.GraphExecutor)

func (UrlEncodedForm) Supports

func (h UrlEncodedForm) Supports(r *http.Request) bool

type Websocket

type Websocket struct {
	Upgrader              websocket.Upgrader
	InitFunc              WebsocketInitFunc
	InitTimeout           time.Duration
	ErrorFunc             WebsocketErrorFunc
	CloseFunc             WebsocketCloseFunc
	KeepAlivePingInterval time.Duration
	PongOnlyInterval      time.Duration
	PingPongInterval      time.Duration
	/* If PingPongInterval has a non-0 duration, then when the server sends a ping
	 * it sets a ReadDeadline of PingPongInterval*2 and if the client doesn't respond
	 * with pong before that deadline is reached then the connection will die with a
	 * 1006 error code.
	 *
	 * MissingPongOk if true, tells the server to not use a ReadDeadline such that a
	 * missing/slow pong response from the client doesn't kill the connection.
	 */
	MissingPongOk bool
	// contains filtered or unexported fields
}

func (Websocket) Do

func (t Websocket) Do(w http.ResponseWriter, r *http.Request, exec graphql.GraphExecutor)

func (Websocket) Supports

func (t Websocket) Supports(r *http.Request) bool

type WebsocketCloseFunc

type WebsocketCloseFunc func(ctx context.Context, closeCode int)

Callback called when websocket is closed.

type WebsocketError

type WebsocketError struct {
	Err error

	// IsReadError flags whether the error occurred on read or write to the websocket
	IsReadError bool
}

func (WebsocketError) Error

func (e WebsocketError) Error() string

type WebsocketErrorFunc

type WebsocketErrorFunc func(ctx context.Context, err error)

type WebsocketInitFunc

type WebsocketInitFunc func(ctx context.Context, initPayload InitPayload) (context.Context, *InitPayload, error)