apifu

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

type Config struct {
	Logger               logrus.FieldLogger
	WebSocketOriginCheck func(r *http.Request) bool

	// If given, these fields will be added to the Node interface.
	AdditionalNodeFields map[string]*graphql.FieldDefinition

	// Invoked to get nodes by their global ids.
	ResolveNodesByGlobalIds func(ctx context.Context, ids []string) ([]interface{}, error)

	// If given, Apollo persisted queries are supported by the API:
	// https://www.apollographql.com/docs/react/api/link/persisted-queries/
	PersistedQueryStorage PersistedQueryStorage

	// When calculating field costs, this is used as the default. This is typically either
	// `graphql.FieldCost{Resolver: 1}` or left as zero.
	DefaultFieldCost graphql.FieldCost

	// Execute is invoked to execute a GraphQL request. If not given, this is simply
	// graphql.Execute. You may wish to provide this to perform request logging or
	// pre/post-processing.
	Execute func(*graphql.Request, *RequestInfo) *graphql.Response

	// If given, this function is invoked when the servers receives the graphql-ws connection init
	// payload. If an error is returned, it will be sent to the client and the connection will be
	// closed. Otherwise the returned context will become associated with the connection.
	//
	// This is commonly used for authentication.
	HandleGraphQLWSInit func(ctx context.Context, parameters json.RawMessage) (context.Context, error)

	// Explicitly adds named types to the schema. This is generally only required for interface
	// implementations that aren't explicitly referenced elsewhere in the schema.
	AdditionalTypes map[string]graphql.NamedType

	// If given, these function will be executed as the schema is built. It is executed on a clone
	// of the schema and can be used to make last minute modifications to types, such as injecting
	// documentation.
	PreprocessGraphQLSchemaDefinition func(schema *graphql.SchemaDefinition) error

	// If given, this function will be invoked to get the feature set for a request.
	Features func(ctx context.Context) graphql.FeatureSet
	// contains filtered or unexported fields
}

type ConnectionConfig struct {
	// A prefix to use for the connection and edge type names. For example, if you provide
	// "Example", the connection type will be named "ExampleConnection" and the edge type will be
	// "ExampleEdge".
	NamePrefix string

	// An optional description for the connection.
	Description string

	// An optional deprecation reason for the connection.
	DeprecationReason string

	// The direction of the connection. This determines which of the first/last/before/after
	// arguments are defined on the connection.
	Direction ConnectionDirection

	// An optional map of additional arguments to add to the connection.
	Arguments map[string]*graphql.InputValueDefinition

	// If getting all edges for the connection is cheap, you can just provide ResolveAllEdges.
	// ResolveAllEdges should return a slice value, with one item for each edge, and a function that
	// can be used to sort the cursors produced by EdgeCursor.
	ResolveAllEdges func(ctx graphql.FieldContext) (edgeSlice interface{}, cursorLess func(a, b interface{}) bool, err error)

	// If getting all edges for the connection is too expensive for ResolveAllEdges, you can provide
	// ResolveEdges. ResolveEdges is just like ResolveAllEdges, but is only required to return edges
	// within the range defined by the given cursors and is only required to return up to `limit`
	// edges. If limit is negative, the last edges within the range should be returned instead of
	// the first.
	//
	// Returning extra edges or out-of-order edges is fine. They will be sorted and filtered
	// automatically. However, you should ensure that no duplicate edges are returned.
	//
	// If desired, edges outside of the given range may be returned to indicate the presence of more
	// pages before or after the given range. This is completely optional, and the connection's
	// behavior will be fully compliant with the Relay Pagination spec regardless. However,
	// providing these additional edges will allow hasNextPage and hasPreviousPage to be true in
	// scenarios where the spec allows them to be false for performance reasons.
	ResolveEdges func(ctx graphql.FieldContext, after, before interface{}, limit int) (edgeSlice interface{}, cursorLess func(a, b interface{}) bool, err error)

	// If you use ResolveEdges, you can optionally provide ResolveTotalCount to add a totalCount
	// field to the connection. If you use ResolveAllEdges, there is no need to provide this.
	ResolveTotalCount func(ctx graphql.FieldContext) (interface{}, error)

	// CursorType allows the connection to deserialize cursors. It is required for all connections.
	CursorType reflect.Type

	// EdgeCursor should return a value that can be used to determine the edge's relative ordering.
	// For example, this might be a struct with a name and id for a connection whose edges are
	// sorted by name. The value must be able to be marshaled to and from binary. This function
	// should return the type of cursor assigned to CursorType.
	EdgeCursor func(edge interface{}) interface{}

	// EdgeFields should provide definitions for the fields of each node. You must provide the
	// "node" field, but the "cursor" field will be provided for you.
	EdgeFields map[string]*graphql.FieldDefinition

	// The connection will implement these interfaces. If any of the interfaces define an edge
	// field as an interface, this connection's edges will also implement that interface.
	ImplementedInterfaces []*graphql.InterfaceType

	// This connection is only available for introspection and use when the given features are enabled.
	RequiredFeatures graphql.FeatureSet
}

type ConnectionDirection int

type ConnectionFieldDefinitionConfig struct {
	// The type of the connection.
	Type graphql.Type

	// The direction of the connection.
	Direction ConnectionDirection

	// An optional description for the connection field.
	Description string

	// An optional deprecation reason for the connection field.
	DeprecationReason string

	// An optional map of additional arguments to add to the field.
	Arguments map[string]*graphql.InputValueDefinition

	// This connection is only available for introspection and use when the given features are enabled.
	RequiredFeatures graphql.FeatureSet
}

type ConnectionInterfaceConfig struct {
	// A prefix to use for the connection and edge type names. For example, if you provide
	// "Example", the connection type will be named "ExampleConnection" and the edge type will be
	// "ExampleEdge".
	NamePrefix string

	// EdgeFields should provide definitions for the fields of each node. You must provide the
	// "node" field, but the "cursor" field will be provided for you.
	EdgeFields map[string]*graphql.FieldDefinition

	// If true, implementations must provide the "totalCount" field.
	HasTotalCount bool

	// This connection is only available for introspection and use when the given features are enabled.
	RequiredFeatures graphql.FeatureSet
}

type PageInfo struct {
	HasPreviousPage bool
	HasNextPage     bool
	StartCursor     string
	EndCursor       string
}

type PersistedQueryStorage interface {
	// GetPersistedQuery should return the query if it's available or an empty string otherwise.
	GetPersistedQuery(ctx context.Context, hash []byte) string

	// PersistQuery should persist the query with the given hash.
	PersistQuery(ctx context.Context, query string, hash []byte)
}

type RequestInfo struct {
	Cost int
}

type SubscriptionSourceStream struct {
	// A channel of events. The channel can be of any type.
	EventChannel interface{}

	// Stop is invoked when the subscription should be stopped and the event channel should be
	// closed.
	Stop func()
}

type TimeBasedConnectionConfig struct {
	// An optional description for the connection.
	Description string

	// An optional deprecation reason for the connection.
	DeprecationReason string

	// A required prefix for the type names. For a field named "friendsConnection" on a User type,
	// the recommended prefix would be "UserFriends". This will result in types named
	// "UserFriendsConnection" and "UserFriendsEdge".
	NamePrefix string

	// This function should return a TimeBasedCursor for the given edge.
	EdgeCursor func(edge interface{}) TimeBasedCursor

	// Returns the fields for the edge. This should always at least include a "node" field.
	EdgeFields map[string]*graphql.FieldDefinition

	// The getter for the edges. If limit is zero, all edges within the given range should be
	// returned. If limit is greater than zero, up to limit edges at the start of the range should
	// be returned. If limit is less than zero, up to -limit edge at the end of the range should be
	// returned.
	EdgeGetter func(ctx graphql.FieldContext, minTime time.Time, maxTime time.Time, limit int) (interface{}, error)

	// An optional map of additional arguments to add to the connection.
	Arguments map[string]*graphql.InputValueDefinition

	// To support the "totalCount" connection field, you can provide this method.
	ResolveTotalCount func(ctx graphql.FieldContext) (interface{}, error)

	// The connection will implement these interfaces. If any of the interfaces define an edge
	// field as an interface, this connection's edges will also implement that interface.
	ImplementedInterfaces []*graphql.InterfaceType

	// This connection is only available for introspection and use when the given features are enabled.
	RequiredFeatures graphql.FeatureSet
}

type TimeBasedCursor struct {
	Nano int64
	Id   string
}