dataloader

package
v0.0.0-...-c84d29a Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: May 22, 2020 License: MIT Imports: 15 Imported by: 0

README

dataloader

This example uses dataloaden to avoiding n+1 queries.

There is also nicksrandall/dataloader if you wanted to avoid doing more codegeneration.

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

func LoaderMiddleware 

func LoaderMiddleware(next http.Handler) http.Handler

nolint: gosec

func NewExecutableSchema 

func NewExecutableSchema(cfg Config) graphql.ExecutableSchema

NewExecutableSchema creates an ExecutableSchema from the ResolverRoot interface.

Types

type Address 

type Address struct {
	ID      int    `json:"id"`
	Street  string `json:"street"`
	Country string `json:"country"`
}

type AddressLoader 

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

AddressLoader batches and caches requests

func NewAddressLoader 

func NewAddressLoader(config AddressLoaderConfig) *AddressLoader

NewAddressLoader creates a new AddressLoader given a fetch, wait, and maxBatch

func (*AddressLoader) Clear 

func (l *AddressLoader) Clear(key int)

Clear the value at key from the cache, if it exists

func (*AddressLoader) Load 

func (l *AddressLoader) Load(key int) (*Address, error)

Load a Address by key, batching and caching will be applied automatically

func (*AddressLoader) LoadAll 

func (l *AddressLoader) LoadAll(keys []int) ([]*Address, []error)

LoadAll fetches many keys at once. It will be broken into appropriate sized sub batches depending on how the loader is configured

func (*AddressLoader) LoadAllThunk 

func (l *AddressLoader) LoadAllThunk(keys []int) func() ([]*Address, []error)

LoadAllThunk returns a function that when called will block waiting for a Addresss. This method should be used if you want one goroutine to make requests to many different data loaders without blocking until the thunk is called.

func (*AddressLoader) LoadThunk 

func (l *AddressLoader) LoadThunk(key int) func() (*Address, error)

LoadThunk returns a function that when called will block waiting for a Address. This method should be used if you want one goroutine to make requests to many different data loaders without blocking until the thunk is called.

func (*AddressLoader) Prime 

func (l *AddressLoader) Prime(key int, value *Address) bool

Prime the cache with the provided key and value. If the key already exists, no change is made and false is returned. (To forcefully prime the cache, clear the key first with loader.clear(key).prime(key, value).)

type AddressLoaderConfig 

type AddressLoaderConfig struct {
	// Fetch is a method that provides the data for the loader
	Fetch func(keys []int) ([]*Address, []error)

	// Wait is how long wait before sending a batch
	Wait time.Duration

	// MaxBatch will limit the maximum number of keys to send in one batch, 0 = not limit
	MaxBatch int
}

AddressLoaderConfig captures the config to create a new AddressLoader

type ComplexityRoot 

type ComplexityRoot struct {
	Address struct {
		Country func(childComplexity int) int
		ID      func(childComplexity int) int
		Street  func(childComplexity int) int
	}

	Customer struct {
		Address func(childComplexity int) int
		ID      func(childComplexity int) int
		Name    func(childComplexity int) int
		Orders  func(childComplexity int) int
	}

	Item struct {
		Name func(childComplexity int) int
	}

	Order struct {
		Amount func(childComplexity int) int
		Date   func(childComplexity int) int
		ID     func(childComplexity int) int
		Items  func(childComplexity int) int
	}

	Query struct {
		Customers func(childComplexity int) int
		Torture1d func(childComplexity int, customerIds []int) int
		Torture2d func(childComplexity int, customerIds [][]int) int
	}
}

type Config 

type Config struct {
	Resolvers  ResolverRoot
	Directives DirectiveRoot
	Complexity ComplexityRoot
}

type Customer 

type Customer struct {
	ID        int    `json:"id"`
	Name      string `json:"name"`
	AddressID int
}

type CustomerResolver 

type CustomerResolver interface {
	Address(ctx context.Context, obj *Customer) (*Address, error)
	Orders(ctx context.Context, obj *Customer) ([]*Order, error)
}

type DirectiveRoot 

type DirectiveRoot struct {
}

type Item 

type Item struct {
	Name string `json:"name"`
}

type ItemSliceLoader 

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

ItemSliceLoader batches and caches requests

func NewItemSliceLoader 

func NewItemSliceLoader(config ItemSliceLoaderConfig) *ItemSliceLoader

NewItemSliceLoader creates a new ItemSliceLoader given a fetch, wait, and maxBatch

func (*ItemSliceLoader) Clear 

func (l *ItemSliceLoader) Clear(key int)

Clear the value at key from the cache, if it exists

func (*ItemSliceLoader) Load 

func (l *ItemSliceLoader) Load(key int) ([]*Item, error)

Load a Item by key, batching and caching will be applied automatically

func (*ItemSliceLoader) LoadAll 

func (l *ItemSliceLoader) LoadAll(keys []int) ([][]*Item, []error)

LoadAll fetches many keys at once. It will be broken into appropriate sized sub batches depending on how the loader is configured

func (*ItemSliceLoader) LoadAllThunk 

func (l *ItemSliceLoader) LoadAllThunk(keys []int) func() ([][]*Item, []error)

LoadAllThunk returns a function that when called will block waiting for a Items. This method should be used if you want one goroutine to make requests to many different data loaders without blocking until the thunk is called.

func (*ItemSliceLoader) LoadThunk 

func (l *ItemSliceLoader) LoadThunk(key int) func() ([]*Item, error)

LoadThunk returns a function that when called will block waiting for a Item. This method should be used if you want one goroutine to make requests to many different data loaders without blocking until the thunk is called.

func (*ItemSliceLoader) Prime 

func (l *ItemSliceLoader) Prime(key int, value []*Item) bool

Prime the cache with the provided key and value. If the key already exists, no change is made and false is returned. (To forcefully prime the cache, clear the key first with loader.clear(key).prime(key, value).)

type ItemSliceLoaderConfig 

type ItemSliceLoaderConfig struct {
	// Fetch is a method that provides the data for the loader
	Fetch func(keys []int) ([][]*Item, []error)

	// Wait is how long wait before sending a batch
	Wait time.Duration

	// MaxBatch will limit the maximum number of keys to send in one batch, 0 = not limit
	MaxBatch int
}

ItemSliceLoaderConfig captures the config to create a new ItemSliceLoader

type Order 

type Order struct {
	ID     int       `json:"id"`
	Date   time.Time `json:"date"`
	Amount float64   `json:"amount"`
}

type OrderResolver 

type OrderResolver interface {
	Items(ctx context.Context, obj *Order) ([]*Item, error)
}

type OrderSliceLoader 

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

OrderSliceLoader batches and caches requests

func NewOrderSliceLoader 

func NewOrderSliceLoader(config OrderSliceLoaderConfig) *OrderSliceLoader

NewOrderSliceLoader creates a new OrderSliceLoader given a fetch, wait, and maxBatch

func (*OrderSliceLoader) Clear 

func (l *OrderSliceLoader) Clear(key int)

Clear the value at key from the cache, if it exists

func (*OrderSliceLoader) Load 

func (l *OrderSliceLoader) Load(key int) ([]*Order, error)

Load a Order by key, batching and caching will be applied automatically

func (*OrderSliceLoader) LoadAll 

func (l *OrderSliceLoader) LoadAll(keys []int) ([][]*Order, []error)

LoadAll fetches many keys at once. It will be broken into appropriate sized sub batches depending on how the loader is configured

func (*OrderSliceLoader) LoadAllThunk 

func (l *OrderSliceLoader) LoadAllThunk(keys []int) func() ([][]*Order, []error)

LoadAllThunk returns a function that when called will block waiting for a Orders. This method should be used if you want one goroutine to make requests to many different data loaders without blocking until the thunk is called.

func (*OrderSliceLoader) LoadThunk 

func (l *OrderSliceLoader) LoadThunk(key int) func() ([]*Order, error)

LoadThunk returns a function that when called will block waiting for a Order. This method should be used if you want one goroutine to make requests to many different data loaders without blocking until the thunk is called.

func (*OrderSliceLoader) Prime 

func (l *OrderSliceLoader) Prime(key int, value []*Order) bool

Prime the cache with the provided key and value. If the key already exists, no change is made and false is returned. (To forcefully prime the cache, clear the key first with loader.clear(key).prime(key, value).)

type OrderSliceLoaderConfig 

type OrderSliceLoaderConfig struct {
	// Fetch is a method that provides the data for the loader
	Fetch func(keys []int) ([][]*Order, []error)

	// Wait is how long wait before sending a batch
	Wait time.Duration

	// MaxBatch will limit the maximum number of keys to send in one batch, 0 = not limit
	MaxBatch int
}

OrderSliceLoaderConfig captures the config to create a new OrderSliceLoader

type QueryResolver 

type QueryResolver interface {
	Customers(ctx context.Context) ([]*Customer, error)
	Torture1d(ctx context.Context, customerIds []int) ([]*Customer, error)
	Torture2d(ctx context.Context, customerIds [][]int) ([][]*Customer, error)
}

type Resolver 

type Resolver struct{}

func (*Resolver) Customer 

func (r *Resolver) Customer() CustomerResolver

func (*Resolver) Order 

func (r *Resolver) Order() OrderResolver

func (*Resolver) Query 

func (r *Resolver) Query() QueryResolver

type ResolverRoot 

type ResolverRoot interface {
	Customer() CustomerResolver
	Order() OrderResolver
	Query() QueryResolver
}

Source Files

View all Source files

Directories

Path Synopsis

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.