entgql

Documentation

Index

• Constants
• Variables
• func ErrNodeNotFound(id interface{}) *gqlerror.Error
• type Annotation
  • func Bind() Annotation
  • func MapsTo(names ...string) Annotation
  • func OrderField(name string) Annotation
  • func Skip() Annotation
  • func Type(name string) Annotation
  • func Unbind() Annotation
  • func (a *Annotation) Decode(annotation interface{}) error
  • func (a Annotation) Merge(other schema.Annotation) schema.Annotation
  • func (Annotation) Name() string
• type Extension
  • func NewExtension(opts ...ExtensionOption) (*Extension, error)
  • func (e *Extension) Hooks() []gen.Hook
  • func (e *Extension) Templates() []*gen.Template
• type ExtensionOption
  • func WithConfigPath(path string, gqlgenOptions ...api.Option) ExtensionOption
  • func WithMapScalarFunc(scalarFunc func(*gen.Field, gen.Op) string) ExtensionOption
  • func WithSchemaPath(path string) ExtensionOption
  • func WithTemplates(templates ...*gen.Template) ExtensionOption
  • func WithWhereFilters(b bool) ExtensionOption
• type Transactioner
  • func (Transactioner) ExtensionName() string
  • func (t Transactioner) InterceptResponse(ctx context.Context, next graphql.ResponseHandler) *graphql.Response
  • func (Transactioner) MutateOperationContext(_ context.Context, oc *graphql.OperationContext) *gqlerror.Error
  • func (t Transactioner) Validate(graphql.ExecutableSchema) error
• type TxOpener
• type TxOpenerFunc
  • func (f TxOpenerFunc) OpenTx(ctx context.Context) (context.Context, driver.Tx, error)

Constants

const GQLConfigAnnotation = "GQLConfig"

GQLConfigAnnotation is the annotation key/name that holds gqlgen configuration if it was provided by the `WithConfigPath` option.

Variables

var (
	// CollectionTemplate adds fields collection support using auto eager-load ent edges.
	// More info can be found here: https://spec.graphql.org/June2018/#sec-Field-Collection.
	CollectionTemplate = parseT("template/collection.tmpl")

	// EnumTemplate adds a template implementing MarshalGQL/UnmarshalGQL methods for enums.
	EnumTemplate = parseT("template/enum.tmpl")

	// NodeTemplate implements the Relay Node interface for all types.
	NodeTemplate = parseT("template/node.tmpl")

	// PaginationTemplate adds pagination support according to the GraphQL Cursor Connections Spec.
	// More info can be found in the following link: https://relay.dev/graphql/connections.htm.
	PaginationTemplate = parseT("template/pagination.tmpl")

	// TransactionTemplate adds support for ent.Client for opening transactions for the transaction
	// middleware. See transaction.go for for information.
	TransactionTemplate = parseT("template/transaction.tmpl")

	// EdgeTemplate adds edge resolution using eager-loading with a query fallback.
	EdgeTemplate = parseT("template/edge.tmpl")

	// WhereTemplate adds a template for generating <T>WhereInput filters for each schema type.
	WhereTemplate = parseT("template/where_input.tmpl")

	// AllTemplates holds all templates for extending ent to support GraphQL.
	AllTemplates = []*gen.Template{
		CollectionTemplate,
		EnumTemplate,
		NodeTemplate,
		PaginationTemplate,
		TransactionTemplate,
		EdgeTemplate,
	}

	// TemplateFuncs contains the extra template functions used by entgql.
	TemplateFuncs = template.FuncMap{
		"fieldCollections": fieldCollections,
		"filterEdges":      filterEdges,
		"filterFields":     filterFields,
		"filterNodes":      filterNodes,
		"findIDType":       findIDType,
	}
)

Functions

func ErrNodeNotFound

func ErrNodeNotFound(id interface{}) *gqlerror.Error

ErrNodeNotFound creates a node not found graphql error.

Types

type Annotation

type Annotation struct {
	// OrderField is the ordering field as defined in graphql schema.
	OrderField string `json:"OrderField,omitempty"`
	// Unbind implies the edge field name in GraphQL schema is not equivalent
	// to the name used in ent schema. That means, by default, edges with this
	// annotation will not be eager-loaded on Paginate calls. See the `MapsTo`
	// option in order to load edges be different name mapping.
	Unbind bool `json:"Unbind,omitempty"`
	// Mapping is the edge field names as defined in graphql schema.
	Mapping []string `json:"Mapping,omitempty"`
	// Type is the underlying GraphQL type name (e.g. Boolean).
	Type string `json:"Type,omitempty"`
	// Skip exclude the type
	Skip bool `json:"Skip,omitempty"`
}

Annotation annotates fields and edges with metadata for templates.

func Bind

func Bind() Annotation

Bind returns a binding annotation.

No-op function to avoid breaking the existing schema. You can safely remove this function from your scheme.

Deprecated: the Bind option predates the Unbind option, and it is planned to be removed in future versions. Users should not use this annotation as it is a no-op call, or use `Unbind` in order to disable `Bind`.

func MapsTo

func MapsTo(names ...string) Annotation

MapsTo returns a mapping annotation.

func OrderField

func OrderField(name string) Annotation

OrderField returns an order field annotation.

func Skip

func Skip() Annotation

Skip returns a skip annotation.

func Type

func Type(name string) Annotation

Type returns a type mapping annotation.

func Unbind

func Unbind() Annotation

Unbind implies the edge field name in GraphQL schema is not equivalent to the name used in ent schema. That means, by default, edges with this annotation will not be eager-loaded on Paginate calls. See the `MapsTo` option in order to load edges be different name mapping.

func (*Annotation) Decode

func (a *Annotation) Decode(annotation interface{}) error

Decode unmarshal annotation

func (Annotation) Merge

func (a Annotation) Merge(other schema.Annotation) schema.Annotation

Merge implements the schema.Merger interface.

func (Annotation) Name

func (Annotation) Name() string

Name implements ent.Annotation interface.

type Extension

type Extension struct {
	entc.DefaultExtension
	// contains filtered or unexported fields
}

Extension implements the entc.Extension for providing GraphQL integration.

func NewExtension

func NewExtension(opts ...ExtensionOption) (*Extension, error)

NewExtension creates a new extension with the given configuration.

ex, err := entgql.NewExtension(
	entgql.WithWhereFilters(true),
	entgql.WithSchemaPath("../schema.graphql"),
)

func (*Extension) Hooks

func (e *Extension) Hooks() []gen.Hook

Hooks of the extension.

func (*Extension) Templates

func (e *Extension) Templates() []*gen.Template

Templates of the extension.

type ExtensionOption

type ExtensionOption func(*Extension) error

ExtensionOption allows for managing the Extension configuration using functional options.

func WithConfigPath

func WithConfigPath(path string, gqlgenOptions ...api.Option) ExtensionOption

WithConfigPath sets the filepath to gqlgen.yml configuration file and injects its parsed version to the global annotations.

Note that, enabling this option is recommended as it improves the GraphQL integration,

func WithMapScalarFunc

func WithMapScalarFunc(scalarFunc func(*gen.Field, gen.Op) string) ExtensionOption

WithMapScalarFunc allows users to provides a custom function that maps an ent.Field (*gen.Field) into its GraphQL scalar type. If the function returns an empty string, the extension fallbacks to the its default mapping.

ex, err := entgql.NewExtension(
	entgql.WithMapScalarFunc(func(f *gen.Field, op gen.Op) string {
		if t, ok := knowType(f, op); ok {
			return t
		}
		// Fallback to the default mapping.
		return ""
	}),
)

func WithSchemaPath

func WithSchemaPath(path string) ExtensionOption

WithSchemaPath sets the filepath to the GraphQL schema to write the generated Ent types. If the file does not exist, it will generate a new schema. Please note, that your gqlgen.yml config file should be updated as follows to support multiple schema files:

schema:
 - schema.graphql // existing schema.
 - ent.graphql	  // generated schema.

func WithTemplates

func WithTemplates(templates ...*gen.Template) ExtensionOption

WithTemplates overrides the default templates (entgql.AllTemplates) with specific templates.

func WithWhereFilters

func WithWhereFilters(b bool) ExtensionOption

WithWhereFilters configures the extension to either add or remove the WhereTemplate from the code generation templates.

The WhereTemplate generates GraphQL filters to all types in the ent/schema.

type Transactioner

type Transactioner struct{ TxOpener }

Transactioner for graphql mutations.

func (Transactioner) ExtensionName

func (Transactioner) ExtensionName() string

ExtensionName returns the extension name.

func (Transactioner) InterceptResponse

func (t Transactioner) InterceptResponse(ctx context.Context, next graphql.ResponseHandler) *graphql.Response

InterceptResponse runs graphql mutations under a transaction.

func (Transactioner) MutateOperationContext

func (Transactioner) MutateOperationContext(_ context.Context, oc *graphql.OperationContext) *gqlerror.Error

MutateOperationContext serializes field resolvers during mutations.

func (Transactioner) Validate

func (t Transactioner) Validate(graphql.ExecutableSchema) error

Validate is called when adding an extension to the server, it allows validation against the servers schema.

type TxOpener

type TxOpener interface {
	OpenTx(ctx context.Context) (context.Context, driver.Tx, error)
}

TxOpener represents types than can open transactions.

type TxOpenerFunc

type TxOpenerFunc func(ctx context.Context) (context.Context, driver.Tx, error)

The TxOpenerFunc type is an adapter to allow the use of ordinary functions as tx openers.

func (TxOpenerFunc) OpenTx

func (f TxOpenerFunc) OpenTx(ctx context.Context) (context.Context, driver.Tx, error)

OpenTx returns f(ctx).