graphqlws

type Client struct {
	// contains filtered or unexported fields
}

type ClientConfig struct {

	// Logger can be used to customize the way the client logs information.
	// A nil value on this field will cause all logs to be discarded. Logs
	// are only meant to be used for troubleshooting, so this is usually the
	// desired behaviour.
	Logger Logger

	// Address defines the address component of the URL that will be used in
	// the request to connect to the server.
	Address string

	// Path defines the path component of the URL that will be used in the
	// request to connect to the server.
	Path string

	// Dialer can be used to provide the 'websocket.Dialer' that will be
	// used to connect to a server. This may be useful if the client needs
	// to be proxied or make use of a cookiejar. When left as nil, the
	// client will dial using the default dialer (websocket.DefaultDialer).
	Dialer *websocket.Dialer

	// Header can be used to provide a HTTP header that will be combined
	// with the header the client will use in its initial HTTP request.
	// This may be useful if the server handles authentication and
	// authorization via headers. For most cases it will be okay to leave
	// this as nil.
	Header http.Header

	// InitialPayload will be sent to the server during the first stages
	// initializing the connection. A GraphQL web socket server's
	// expectations regarding the initial payload can vary from
	// implementation to implementation, but it is a common requirement that
	// this payload contain information used to authenticate and authorize
	// the client.
	InitialPayload interface{}

	// ReadTimeout determines the maximum length of time a client will wait
	// in between each message received from the server. This setting only
	// comes into effect if the connected server is configured to
	// 'keep-alive' the connection. While in effect, if this interval is
	// ever exceeded the connection will be considered corrupt, causing the
	// client to close itself down. If left as zero, no read timeout will
	// be enforced.
	ReadTimeout time.Duration

	// WriteTimeout determines the maximum length of time a client will wait
	// for the server to receive each message. If this interval is ever
	// exceeded the connection will be considered corrupt, causing the
	// client to close itself down. If left as zero, no write timeout will
	// be enforced.
	WriteTimeout time.Duration
}

type Cluster struct {
	// contains filtered or unexported fields
}

type ClusterConfig struct {

	// Clusterable is the Clusterable object to be managed by the Cluster.
	Clusterable Clusterable

	// Logger can be used to configure the log output of the Cluster.
	Logger Logger

	// Is the Peers object that is used to communicate with the other nodes
	// of the cluster.
	Peers Peers
}

type Clusterable interface {

	// Something Clusterable must be capable of publishing updates.
	Publish(update Update)

	// Schema returns an implementation of Schema, which is used by the
	// implementation of Cluster to reconstruct Update objects that have
	// been received from peers.
	Schema() Schema
}

type GQLDataPayload struct {
	Data   interface{} `json:"data,omitempty"`
	Errors []GQLError  `json:"errors,omitempty"`
}

type GQLError struct {
	Locations  []GQLErrorLocation     `json:"locations,omitempty"`
	Message    string                 `json:"message"`
	Path       []string               `json:"path,omitempty"`
	Extensions map[string]interface{} `json:"extensions,omitempty"`
}

type GQLErrorLocation struct {
	Line   int `json:"line"`
	Column int `json:"column"`
}

type GQLStartPayload struct {
	Query         string                 `json:"query"`
	Variables     map[string]interface{} `json:"variables"`
	OperationName string                 `json:"operationName"`
}

type Logger interface {

	// Info logs a general information message. This is verbose and should
	// be discarded except when troubleshooting.
	Info(message string)

	// Error logs a message describing a non-critical error that has
	// occurred. This is not verbose but is also for troubleshooting
	// purposes. It is okay to discard these messages because the library
	// only logs errors that can be recovered or ignored. Critical errors
	// will always be returned as an error somewhere.
	Error(message string)
}

type Message struct {
	Payload interface{} `json:"payload,omitempty"`
	ID      string      `json:"id,omitempty"`
	Type    MessageType `json:"type"`
}

type MessageType string

type MutationConfig struct {
	Query         string                 `json:"query"`
	Variables     map[string]interface{} `json:"variables"`
	OperationName string                 `json:"operationName"`
}

type Peer interface {
	// Notify sends an Update to the peer.
	Notify(update Update) error
}

type Peers interface {
	// Peers returns a complete list of Peer objects in the cluster.
	Peers() []Peer
}

type QueryConfig struct {
	Query         string                 `json:"query"`
	Variables     map[string]interface{} `json:"variables"`
	OperationName string                 `json:"operationName"`
}

type Schema interface {

	// Fields returns a list of alphabetically sorted strings representing
	// each leaf of a GraphQL schema's subscriptions.
	Fields() []string

	// NewUpdate returns an Update object created from a list of fields. All
	// fields provided should exists in the list of strings returned by the
	// Fields function on this interface.
	NewUpdate(fields ...string) Update

	// UpdateFromObject is a convenience function that will check if the
	// provided object pointer can be found anywhere in the underlying
	// schema, and use the results of this search to create a new Update
	// from all of the identified fields. The function must be smart enough
	// to find the object if it appears multiple times in the same schema.
	UpdateFromObject(o *graphql.Object) Update

	// UpdateFromJSON must be able to recreate an Update object from a JSON
	// payload (as created by the Update object's MarshalJSON function). It
	// must also be able to validate that the payload perfectly matches the
	// schema. This is necessary to prevent bugs caused by mismatched
	// GraphQL schemas that could occur when Updates are published to a
	// cluster.
	UpdateFromJSON(data []byte) (Update, error)
}

type Server struct {
	// contains filtered or unexported fields
}

type ServerConfig struct {
	Logger          Logger
	Schema          graphql.Schema
	EnableKeepAlive bool
	PollingInterval time.Duration
	ReadTimeout     time.Duration
	WriteTimeout    time.Duration
}

type SimplePeer struct {
	Client *http.Client
	Header http.Header
	URL    *url.URL
}

type StaticPeers []Peer

type Subscription struct {
	// contains filtered or unexported fields
}

type SubscriptionConfig struct {
	Query         string
	Variables     map[string]interface{}
	OperationName string
	DataCallback  func(payload *GQLDataPayload)
	ErrorCallback func(err error)
}

type Update interface {

	// When martialled into JSON, an Update should contain enough
	// information for a Schema to completely reconstruct it and also
	// validate that it is meant for the same Schema. This is necessary to
	// prevent bugs caused by mismatched GraphQL schemas that could occur
	// when Updates are published to a cluster.
	json.Marshaler

	// Overlaps returns true if the two Update objects share at least one
	// field (or leaf) of the GraphQL schema.
	Overlaps(update Update) bool
}