graph

Documentation

Index

• func MarshalFloat32(f float32) graphql.Marshaler
• func NewExecutableSchema(cfg Config) graphql.ExecutableSchema
• func UnmarshalFloat32(v interface{}) (float32, error)
• type ComplexityRoot
• type Config
• type DirectiveRoot
• type MutationResolver
• type QueryResolver
• type Resolver
  • func NewResolver(c ResolverConfig) *Resolver
  • func (r *Resolver) Mutation() MutationResolver
  • func (r *Resolver) Query() QueryResolver
• type ResolverConfig
• type ResolverRoot

Functions

func MarshalFloat32

func MarshalFloat32(f float32) graphql.Marshaler

func NewExecutableSchema

func NewExecutableSchema(cfg Config) graphql.ExecutableSchema

NewExecutableSchema creates an ExecutableSchema from the ResolverRoot interface.

func UnmarshalFloat32

func UnmarshalFloat32(v interface{}) (float32, error)

Types

type ComplexityRoot

type ComplexityRoot struct {
	Expense struct {
		Amount      func(childComplexity int) int
		CreatedAt   func(childComplexity int) int
		Date        func(childComplexity int) int
		Description func(childComplexity int) int
		ID          func(childComplexity int) int
		UpdatedAt   func(childComplexity int) int
		UserID      func(childComplexity int) int
	}

	Mutation struct {
		CreateExpense func(childComplexity int, data model.CreateExpenseInput) int
		UpdateExpense func(childComplexity int, data model.UpdateExpenseInput) int
	}

	PaginatedExpenseResponse struct {
		Cursor   func(childComplexity int) int
		Expenses func(childComplexity int) int
	}

	Query struct {
		Expense  func(childComplexity int, userID uuid.UUID, id uuid.UUID) int
		Expenses func(childComplexity int, params model.GetMultipleInput) int
	}
}

type Config

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

type DirectiveRoot

type DirectiveRoot struct {
}

type MutationResolver

type MutationResolver interface {
	CreateExpense(ctx context.Context, data model.CreateExpenseInput) (*model.Expense, error)
	UpdateExpense(ctx context.Context, data model.UpdateExpenseInput) (*model.Expense, error)
}

type QueryResolver

type QueryResolver interface {
	Expense(ctx context.Context, userID uuid.UUID, id uuid.UUID) (*model.Expense, error)
	Expenses(ctx context.Context, params model.GetMultipleInput) (*model.PaginatedExpenseResponse, error)
}

type Resolver

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

func NewResolver

func NewResolver(c ResolverConfig) *Resolver

func (*Resolver) Mutation

func (r *Resolver) Mutation() MutationResolver

Mutation returns MutationResolver implementation.

func (*Resolver) Query

func (r *Resolver) Query() QueryResolver

Query returns QueryResolver implementation.

type ResolverConfig

type ResolverConfig struct {
	GetExpenseHandler         iquery.IHandler[*expensqry.GetQuery, *expensemodel.Expense]
	GetMultipleExpenseHandler iquery.IHandler[*expensqry.GetMultipleQuery, []*expensemodel.Expense]
	AddExpenseHandler         icmd.IHandler[*expensecmd.AddCommand, *expensemodel.Expense]
	PatchExpenseHandler       icmd.IHandler[*expensecmd.PatchCommand, *expensemodel.Expense]
}

type ResolverRoot

type ResolverRoot interface {
	Mutation() MutationResolver
	Query() QueryResolver
}