generated

Documentation

Index

• func NewExecutableSchema(cfg Config) graphql.ExecutableSchema
• type AppleCreateInput
• type AppleQueryInput
• type AppleUpdateInput
• type ClearQueueInput
• type ComplexityRoot
• type Config
• type DeleteInput
• type DirectiveRoot
• type Mutation
• type MutationResolver
• type Query
• type QueryResolver
• type Queue
• type RefreshInput
• type ResolverRoot
• type Subscription
• type SubscriptionResolver
• type UserInput
• type ViewerResolver

Functions

func NewExecutableSchema

func NewExecutableSchema(cfg Config) graphql.ExecutableSchema

NewExecutableSchema creates an ExecutableSchema from the ResolverRoot interface.

Types

type AppleCreateInput

type AppleCreateInput struct {
	Variety  types.AppleVariety `json:"variety"`
	UserID   uint               `json:"userId"`
	Quantity int                `json:"quantity"`
}

type AppleQueryInput

type AppleQueryInput struct {
	UserID  *uint   `json:"userId,omitempty"`
	Variety *string `json:"variety,omitempty"`
}

type AppleUpdateInput

type AppleUpdateInput struct {
	AppleID  uint                `json:"appleId"`
	UserID   *uint               `json:"userId,omitempty"`
	Variety  *types.AppleVariety `json:"variety,omitempty"`
	Quantity *int                `json:"quantity,omitempty"`
}

type ClearQueueInput

type ClearQueueInput struct {
	UserID *uint `json:"userId,omitempty"`
}

type ComplexityRoot

type ComplexityRoot struct {
}

type Config

type Config struct {
	Schema     *ast.Schema
	Resolvers  ResolverRoot
	Directives DirectiveRoot
	Complexity ComplexityRoot
}

type DeleteInput

type DeleteInput struct {
	Ids []*uint `json:"ids"`
}

type DirectiveRoot

type DirectiveRoot struct {
	HasRole func(ctx context.Context, obj interface{}, next graphql.Resolver, role types.Role) (res interface{}, err error)
}

type Mutation

type Mutation struct {
}

type MutationResolver

type MutationResolver interface {
	CreateApple(ctx context.Context, input AppleCreateInput) ([]*types.Apple, error)
	UpdateApple(ctx context.Context, input AppleUpdateInput) (bool, error)
	DeleteApple(ctx context.Context, input DeleteInput) (bool, error)
	Login(ctx context.Context, input types.LoginInput) (*types.JWT, error)
	Signup(ctx context.Context, input UserInput) (*types.JWT, error)
	RefreshToken(ctx context.Context, input RefreshInput) (*types.JWT, error)
	ToggleQueuePaused(ctx context.Context) (bool, error)
	ClearQueue(ctx context.Context, input ClearQueueInput) (bool, error)
}

type Query

type Query struct {
}

type QueryResolver

type QueryResolver interface {
	Heartbeat(ctx context.Context) (bool, error)
	Viewer(ctx context.Context) (*types.User, error)
}

type Queue

type Queue struct {
	Name             string `json:"name"`
	MemoryUsageBytes int    `json:"memoryUsageBytes"`
	Size             int    `json:"size"`
	Groups           int    `json:"groups"`
	LatencyMsec      int    `json:"latencyMsec"`
	DisplayLatency   string `json:"displayLatency"`
	Active           int    `json:"active"`
	Pending          int    `json:"pending"`
	Aggregating      int    `json:"aggregating"`
	Scheduled        int    `json:"scheduled"`
	Retry            int    `json:"retry"`
	Archived         int    `json:"archived"`
	Completed        int    `json:"completed"`
	Processed        int    `json:"processed"`
	Succeeded        int    `json:"succeeded"`
	Failed           int    `json:"failed"`
	Paused           bool   `json:"paused"`
	Timestamp        string `json:"timestamp"`
}

type RefreshInput

type RefreshInput struct {
	AccessToken  string `json:"accessToken"`
	RefreshToken string `json:"refreshToken"`
}

type ResolverRoot

type ResolverRoot interface {
	Mutation() MutationResolver
	Query() QueryResolver
	Subscription() SubscriptionResolver
	Viewer() ViewerResolver
}

type Subscription

type Subscription struct {
}

type SubscriptionResolver

type SubscriptionResolver interface {
	Queue(ctx context.Context) (<-chan *Queue, error)
}

type UserInput

type UserInput struct {
	Email    string  `json:"email"`
	Password string  `json:"password"`
	Phone    *string `json:"phone,omitempty"`
}

type ViewerResolver

type ViewerResolver interface {
	AppleConnection(ctx context.Context, obj *types.User, input types.ConnectionInput) (*types.AppleConnection, error)

	Queue(ctx context.Context, obj *types.User) (*Queue, error)
}