gql_pagination.go

// Code generated by ent, DO NOT EDIT.

package ent

import (
	"context"
	"encoding/base64"
	"errors"
	"fmt"
	"io"
	"strconv"
	"strings"

	"entgo.io/ent/dialect/sql"
	"github.com/99designs/gqlgen/graphql"
	"github.com/99designs/gqlgen/graphql/errcode"
	"github.com/fogo-sh/grackdb/ent/discordaccount"
	"github.com/fogo-sh/grackdb/ent/discordbot"
	"github.com/fogo-sh/grackdb/ent/githubaccount"
	"github.com/fogo-sh/grackdb/ent/githuborganization"
	"github.com/fogo-sh/grackdb/ent/githuborganizationmember"
	"github.com/fogo-sh/grackdb/ent/project"
	"github.com/fogo-sh/grackdb/ent/projectassociation"
	"github.com/fogo-sh/grackdb/ent/projectcontributor"
	"github.com/fogo-sh/grackdb/ent/projecttechnology"
	"github.com/fogo-sh/grackdb/ent/repository"
	"github.com/fogo-sh/grackdb/ent/repositorytechnology"
	"github.com/fogo-sh/grackdb/ent/site"
	"github.com/fogo-sh/grackdb/ent/technology"
	"github.com/fogo-sh/grackdb/ent/technologyassociation"
	"github.com/fogo-sh/grackdb/ent/user"
	"github.com/vektah/gqlparser/v2/gqlerror"
	"github.com/vmihailenco/msgpack/v5"
)

// OrderDirection defines the directions in which to order a list of items.
type OrderDirection string

const (
	// OrderDirectionAsc specifies an ascending order.
	OrderDirectionAsc OrderDirection = "ASC"
	// OrderDirectionDesc specifies a descending order.
	OrderDirectionDesc OrderDirection = "DESC"
)

// Validate the order direction value.
func (o OrderDirection) Validate() error {
	if o != OrderDirectionAsc && o != OrderDirectionDesc {
		return fmt.Errorf("%s is not a valid OrderDirection", o)
	}
	return nil
}

// String implements fmt.Stringer interface.
func (o OrderDirection) String() string {
	return string(o)
}

// MarshalGQL implements graphql.Marshaler interface.
func (o OrderDirection) MarshalGQL(w io.Writer) {
	io.WriteString(w, strconv.Quote(o.String()))
}

// UnmarshalGQL implements graphql.Unmarshaler interface.
func (o *OrderDirection) UnmarshalGQL(val interface{}) error {
	str, ok := val.(string)
	if !ok {
		return fmt.Errorf("order direction %T must be a string", val)
	}
	*o = OrderDirection(str)
	return o.Validate()
}

func (o OrderDirection) reverse() OrderDirection {
	if o == OrderDirectionDesc {
		return OrderDirectionAsc
	}
	return OrderDirectionDesc
}

func (o OrderDirection) orderFunc(field string) OrderFunc {
	if o == OrderDirectionDesc {
		return Desc(field)
	}
	return Asc(field)
}

func cursorsToPredicates(direction OrderDirection, after, before *Cursor, field, idField string) []func(s *sql.Selector) {
	var predicates []func(s *sql.Selector)
	if after != nil {
		if after.Value != nil {
			var predicate func([]string, ...interface{}) *sql.Predicate
			if direction == OrderDirectionAsc {
				predicate = sql.CompositeGT
			} else {
				predicate = sql.CompositeLT
			}
			predicates = append(predicates, func(s *sql.Selector) {
				s.Where(predicate(
					s.Columns(field, idField),
					after.Value, after.ID,
				))
			})
		} else {
			var predicate func(string, interface{}) *sql.Predicate
			if direction == OrderDirectionAsc {
				predicate = sql.GT
			} else {
				predicate = sql.LT
			}
			predicates = append(predicates, func(s *sql.Selector) {
				s.Where(predicate(
					s.C(idField),
					after.ID,
				))
			})
		}
	}
	if before != nil {
		if before.Value != nil {
			var predicate func([]string, ...interface{}) *sql.Predicate
			if direction == OrderDirectionAsc {
				predicate = sql.CompositeLT
			} else {
				predicate = sql.CompositeGT
			}
			predicates = append(predicates, func(s *sql.Selector) {
				s.Where(predicate(
					s.Columns(field, idField),
					before.Value, before.ID,
				))
			})
		} else {
			var predicate func(string, interface{}) *sql.Predicate
			if direction == OrderDirectionAsc {
				predicate = sql.LT
			} else {
				predicate = sql.GT
			}
			predicates = append(predicates, func(s *sql.Selector) {
				s.Where(predicate(
					s.C(idField),
					before.ID,
				))
			})
		}
	}
	return predicates
}

// PageInfo of a connection type.
type PageInfo struct {
	HasNextPage     bool    `json:"hasNextPage"`
	HasPreviousPage bool    `json:"hasPreviousPage"`
	StartCursor     *Cursor `json:"startCursor"`
	EndCursor       *Cursor `json:"endCursor"`
}

// Cursor of an edge type.
type Cursor struct {
	ID    int   `msgpack:"i"`
	Value Value `msgpack:"v,omitempty"`
}

// MarshalGQL implements graphql.Marshaler interface.
func (c Cursor) MarshalGQL(w io.Writer) {
	quote := []byte{'"'}
	w.Write(quote)
	defer w.Write(quote)
	wc := base64.NewEncoder(base64.RawStdEncoding, w)
	defer wc.Close()
	_ = msgpack.NewEncoder(wc).Encode(c)
}

// UnmarshalGQL implements graphql.Unmarshaler interface.
func (c *Cursor) UnmarshalGQL(v interface{}) error {
	s, ok := v.(string)
	if !ok {
		return fmt.Errorf("%T is not a string", v)
	}
	if err := msgpack.NewDecoder(
		base64.NewDecoder(
			base64.RawStdEncoding,
			strings.NewReader(s),
		),
	).Decode(c); err != nil {
		return fmt.Errorf("cannot decode cursor: %w", err)
	}
	return nil
}

const errInvalidPagination = "INVALID_PAGINATION"

func validateFirstLast(first, last *int) (err *gqlerror.Error) {
	switch {
	case first != nil && last != nil:
		err = &gqlerror.Error{
			Message: "Passing both `first` and `last` to paginate a connection is not supported.",
		}
	case first != nil && *first < 0:
		err = &gqlerror.Error{
			Message: "`first` on a connection cannot be less than zero.",
		}
		errcode.Set(err, errInvalidPagination)
	case last != nil && *last < 0:
		err = &gqlerror.Error{
			Message: "`last` on a connection cannot be less than zero.",
		}
		errcode.Set(err, errInvalidPagination)
	}
	return err
}

func collectedField(ctx context.Context, path ...string) *graphql.CollectedField {
	fc := graphql.GetFieldContext(ctx)
	if fc == nil {
		return nil
	}
	field := fc.Field
	oc := graphql.GetOperationContext(ctx)
walk:
	for _, name := range path {
		for _, f := range graphql.CollectFields(oc, field.Selections, nil) {
			if f.Alias == name {
				field = f
				continue walk
			}
		}
		return nil
	}
	return &field
}

func hasCollectedField(ctx context.Context, path ...string) bool {
	if graphql.GetFieldContext(ctx) == nil {
		return true
	}
	return collectedField(ctx, path...) != nil
}

const (
	edgesField      = "edges"
	nodeField       = "node"
	pageInfoField   = "pageInfo"
	totalCountField = "totalCount"
)

func paginateLimit(first, last *int) int {
	var limit int
	if first != nil {
		limit = *first + 1
	} else if last != nil {
		limit = *last + 1
	}
	return limit
}

// DiscordAccountEdge is the edge representation of DiscordAccount.
type DiscordAccountEdge struct {
	Node   *DiscordAccount `json:"node"`
	Cursor Cursor          `json:"cursor"`
}

// DiscordAccountConnection is the connection containing edges to DiscordAccount.
type DiscordAccountConnection struct {
	Edges      []*DiscordAccountEdge `json:"edges"`
	PageInfo   PageInfo              `json:"pageInfo"`
	TotalCount int                   `json:"totalCount"`
}

func (c *DiscordAccountConnection) build(nodes []*DiscordAccount, pager *discordaccountPager, after *Cursor, first *int, before *Cursor, last *int) {
	c.PageInfo.HasNextPage = before != nil
	c.PageInfo.HasPreviousPage = after != nil
	if first != nil && *first+1 == len(nodes) {
		c.PageInfo.HasNextPage = true
		nodes = nodes[:len(nodes)-1]
	} else if last != nil && *last+1 == len(nodes) {
		c.PageInfo.HasPreviousPage = true
		nodes = nodes[:len(nodes)-1]
	}
	var nodeAt func(int) *DiscordAccount
	if last != nil {
		n := len(nodes) - 1
		nodeAt = func(i int) *DiscordAccount {
			return nodes[n-i]
		}
	} else {
		nodeAt = func(i int) *DiscordAccount {
			return nodes[i]
		}
	}
	c.Edges = make([]*DiscordAccountEdge, len(nodes))
	for i := range nodes {
		node := nodeAt(i)
		c.Edges[i] = &DiscordAccountEdge{
			Node:   node,
			Cursor: pager.toCursor(node),
		}
	}
	if l := len(c.Edges); l > 0 {
		c.PageInfo.StartCursor = &c.Edges[0].Cursor
		c.PageInfo.EndCursor = &c.Edges[l-1].Cursor
	}
	if c.TotalCount == 0 {
		c.TotalCount = len(nodes)
	}
}

// DiscordAccountPaginateOption enables pagination customization.
type DiscordAccountPaginateOption func(*discordaccountPager) error

// WithDiscordAccountOrder configures pagination ordering.
func WithDiscordAccountOrder(order *DiscordAccountOrder) DiscordAccountPaginateOption {
	if order == nil {
		order = DefaultDiscordAccountOrder
	}
	o := *order
	return func(pager *discordaccountPager) error {
		if err := o.Direction.Validate(); err != nil {
			return err
		}
		if o.Field == nil {
			o.Field = DefaultDiscordAccountOrder.Field
		}
		pager.order = &o
		return nil
	}
}

// WithDiscordAccountFilter configures pagination filter.
func WithDiscordAccountFilter(filter func(*DiscordAccountQuery) (*DiscordAccountQuery, error)) DiscordAccountPaginateOption {
	return func(pager *discordaccountPager) error {
		if filter == nil {
			return errors.New("DiscordAccountQuery filter cannot be nil")
		}
		pager.filter = filter
		return nil
	}
}

type discordaccountPager struct {
	order  *DiscordAccountOrder
	filter func(*DiscordAccountQuery) (*DiscordAccountQuery, error)
}

func newDiscordAccountPager(opts []DiscordAccountPaginateOption) (*discordaccountPager, error) {
	pager := &discordaccountPager{}
	for _, opt := range opts {
		if err := opt(pager); err != nil {
			return nil, err
		}
	}
	if pager.order == nil {
		pager.order = DefaultDiscordAccountOrder
	}
	return pager, nil
}

func (p *discordaccountPager) applyFilter(query *DiscordAccountQuery) (*DiscordAccountQuery, error) {
	if p.filter != nil {
		return p.filter(query)
	}
	return query, nil
}

func (p *discordaccountPager) toCursor(da *DiscordAccount) Cursor {
	return p.order.Field.toCursor(da)
}

func (p *discordaccountPager) applyCursors(query *DiscordAccountQuery, after, before *Cursor) *DiscordAccountQuery {
	for _, predicate := range cursorsToPredicates(
		p.order.Direction, after, before,
		p.order.Field.field, DefaultDiscordAccountOrder.Field.field,
	) {
		query = query.Where(predicate)
	}
	return query
}

func (p *discordaccountPager) applyOrder(query *DiscordAccountQuery, reverse bool) *DiscordAccountQuery {
	direction := p.order.Direction
	if reverse {
		direction = direction.reverse()
	}
	query = query.Order(direction.orderFunc(p.order.Field.field))
	if p.order.Field != DefaultDiscordAccountOrder.Field {
		query = query.Order(direction.orderFunc(DefaultDiscordAccountOrder.Field.field))
	}
	return query
}

func (p *discordaccountPager) orderExpr(reverse bool) sql.Querier {
	direction := p.order.Direction
	if reverse {
		direction = direction.reverse()
	}
	return sql.ExprFunc(func(b *sql.Builder) {
		b.Ident(p.order.Field.field).Pad().WriteString(string(direction))
		if p.order.Field != DefaultDiscordAccountOrder.Field {
			b.Comma().Ident(DefaultDiscordAccountOrder.Field.field).Pad().WriteString(string(direction))
		}
	})
}

// Paginate executes the query and returns a relay based cursor connection to DiscordAccount.
func (da *DiscordAccountQuery) Paginate(
	ctx context.Context, after *Cursor, first *int,
	before *Cursor, last *int, opts ...DiscordAccountPaginateOption,
) (*DiscordAccountConnection, error) {
	if err := validateFirstLast(first, last); err != nil {
		return nil, err
	}
	pager, err := newDiscordAccountPager(opts)
	if err != nil {
		return nil, err
	}
	if da, err = pager.applyFilter(da); err != nil {
		return nil, err
	}
	conn := &DiscordAccountConnection{Edges: []*DiscordAccountEdge{}}
	ignoredEdges := !hasCollectedField(ctx, edgesField)
	if hasCollectedField(ctx, totalCountField) || hasCollectedField(ctx, pageInfoField) {
		hasPagination := after != nil || first != nil || before != nil || last != nil
		if hasPagination || ignoredEdges {
			if conn.TotalCount, err = da.Count(ctx); err != nil {
				return nil, err
			}
			conn.PageInfo.HasNextPage = first != nil && conn.TotalCount > 0
			conn.PageInfo.HasPreviousPage = last != nil && conn.TotalCount > 0
		}
	}
	if ignoredEdges || (first != nil && *first == 0) || (last != nil && *last == 0) {
		return conn, nil
	}

	da = pager.applyCursors(da, after, before)
	da = pager.applyOrder(da, last != nil)
	if limit := paginateLimit(first, last); limit != 0 {
		da.Limit(limit)
	}
	if field := collectedField(ctx, edgesField, nodeField); field != nil {
		if err := da.collectField(ctx, graphql.GetOperationContext(ctx), *field, []string{edgesField, nodeField}); err != nil {
			return nil, err
		}
	}

	nodes, err := da.All(ctx)
	if err != nil {
		return nil, err
	}
	conn.build(nodes, pager, after, first, before, last)
	return conn, nil
}

var (
	// DiscordAccountOrderFieldDiscordID orders DiscordAccount by discord_id.
	DiscordAccountOrderFieldDiscordID = &DiscordAccountOrderField{
		field: discordaccount.FieldDiscordID,
		toCursor: func(da *DiscordAccount) Cursor {
			return Cursor{
				ID:    da.ID,
				Value: da.DiscordID,
			}
		},
	}
	// DiscordAccountOrderFieldUsername orders DiscordAccount by username.
	DiscordAccountOrderFieldUsername = &DiscordAccountOrderField{
		field: discordaccount.FieldUsername,
		toCursor: func(da *DiscordAccount) Cursor {
			return Cursor{
				ID:    da.ID,
				Value: da.Username,
			}
		},
	}
	// DiscordAccountOrderFieldDiscriminator orders DiscordAccount by discriminator.
	DiscordAccountOrderFieldDiscriminator = &DiscordAccountOrderField{
		field: discordaccount.FieldDiscriminator,
		toCursor: func(da *DiscordAccount) Cursor {
			return Cursor{
				ID:    da.ID,
				Value: da.Discriminator,
			}
		},
	}
)

// String implement fmt.Stringer interface.
func (f DiscordAccountOrderField) String() string {
	var str string
	switch f.field {
	case discordaccount.FieldDiscordID:
		str = "DISCORD_ID"
	case discordaccount.FieldUsername:
		str = "USERNAME"
	case discordaccount.FieldDiscriminator:
		str = "DISCRIMINATOR"
	}
	return str
}

// MarshalGQL implements graphql.Marshaler interface.
func (f DiscordAccountOrderField) MarshalGQL(w io.Writer) {
	io.WriteString(w, strconv.Quote(f.String()))
}

// UnmarshalGQL implements graphql.Unmarshaler interface.
func (f *DiscordAccountOrderField) UnmarshalGQL(v interface{}) error {
	str, ok := v.(string)
	if !ok {
		return fmt.Errorf("DiscordAccountOrderField %T must be a string", v)
	}
	switch str {
	case "DISCORD_ID":
		*f = *DiscordAccountOrderFieldDiscordID
	case "USERNAME":
		*f = *DiscordAccountOrderFieldUsername
	case "DISCRIMINATOR":
		*f = *DiscordAccountOrderFieldDiscriminator
	default:
		return fmt.Errorf("%s is not a valid DiscordAccountOrderField", str)
	}
	return nil
}

// DiscordAccountOrderField defines the ordering field of DiscordAccount.
type DiscordAccountOrderField struct {
	field    string
	toCursor func(*DiscordAccount) Cursor
}

// DiscordAccountOrder defines the ordering of DiscordAccount.
type DiscordAccountOrder struct {
	Direction OrderDirection            `json:"direction"`
	Field     *DiscordAccountOrderField `json:"field"`
}

// DefaultDiscordAccountOrder is the default ordering of DiscordAccount.
var DefaultDiscordAccountOrder = &DiscordAccountOrder{
	Direction: OrderDirectionAsc,
	Field: &DiscordAccountOrderField{
		field: discordaccount.FieldID,
		toCursor: func(da *DiscordAccount) Cursor {
			return Cursor{ID: da.ID}
		},
	},
}

// ToEdge converts DiscordAccount into DiscordAccountEdge.
func (da *DiscordAccount) ToEdge(order *DiscordAccountOrder) *DiscordAccountEdge {
	if order == nil {
		order = DefaultDiscordAccountOrder
	}
	return &DiscordAccountEdge{
		Node:   da,
		Cursor: order.Field.toCursor(da),
	}
}

// DiscordBotEdge is the edge representation of DiscordBot.
type DiscordBotEdge struct {
	Node   *DiscordBot `json:"node"`
	Cursor Cursor      `json:"cursor"`
}

// DiscordBotConnection is the connection containing edges to DiscordBot.
type DiscordBotConnection struct {
	Edges      []*DiscordBotEdge `json:"edges"`
	PageInfo   PageInfo          `json:"pageInfo"`
	TotalCount int               `json:"totalCount"`
}

func (c *DiscordBotConnection) build(nodes []*DiscordBot, pager *discordbotPager, after *Cursor, first *int, before *Cursor, last *int) {
	c.PageInfo.HasNextPage = before != nil
	c.PageInfo.HasPreviousPage = after != nil
	if first != nil && *first+1 == len(nodes) {
		c.PageInfo.HasNextPage = true
		nodes = nodes[:len(nodes)-1]
	} else if last != nil && *last+1 == len(nodes) {
		c.PageInfo.HasPreviousPage = true
		nodes = nodes[:len(nodes)-1]
	}
	var nodeAt func(int) *DiscordBot
	if last != nil {
		n := len(nodes) - 1
		nodeAt = func(i int) *DiscordBot {
			return nodes[n-i]
		}
	} else {
		nodeAt = func(i int) *DiscordBot {
			return nodes[i]
		}
	}
	c.Edges = make([]*DiscordBotEdge, len(nodes))
	for i := range nodes {
		node := nodeAt(i)
		c.Edges[i] = &DiscordBotEdge{
			Node:   node,
			Cursor: pager.toCursor(node),
		}
	}
	if l := len(c.Edges); l > 0 {
		c.PageInfo.StartCursor = &c.Edges[0].Cursor
		c.PageInfo.EndCursor = &c.Edges[l-1].Cursor
	}
	if c.TotalCount == 0 {
		c.TotalCount = len(nodes)
	}
}

// DiscordBotPaginateOption enables pagination customization.
type DiscordBotPaginateOption func(*discordbotPager) error

// WithDiscordBotOrder configures pagination ordering.
func WithDiscordBotOrder(order *DiscordBotOrder) DiscordBotPaginateOption {
	if order == nil {
		order = DefaultDiscordBotOrder
	}
	o := *order
	return func(pager *discordbotPager) error {
		if err := o.Direction.Validate(); err != nil {
			return err
		}
		if o.Field == nil {
			o.Field = DefaultDiscordBotOrder.Field
		}
		pager.order = &o
		return nil
	}
}

// WithDiscordBotFilter configures pagination filter.
func WithDiscordBotFilter(filter func(*DiscordBotQuery) (*DiscordBotQuery, error)) DiscordBotPaginateOption {
	return func(pager *discordbotPager) error {
		if filter == nil {
			return errors.New("DiscordBotQuery filter cannot be nil")
		}
		pager.filter = filter
		return nil
	}
}

type discordbotPager struct {
	order  *DiscordBotOrder
	filter func(*DiscordBotQuery) (*DiscordBotQuery, error)
}

func newDiscordBotPager(opts []DiscordBotPaginateOption) (*discordbotPager, error) {
	pager := &discordbotPager{}
	for _, opt := range opts {
		if err := opt(pager); err != nil {
			return nil, err
		}
	}
	if pager.order == nil {
		pager.order = DefaultDiscordBotOrder
	}
	return pager, nil
}

func (p *discordbotPager) applyFilter(query *DiscordBotQuery) (*DiscordBotQuery, error) {
	if p.filter != nil {
		return p.filter(query)
	}
	return query, nil
}

func (p *discordbotPager) toCursor(db *DiscordBot) Cursor {
	return p.order.Field.toCursor(db)
}

func (p *discordbotPager) applyCursors(query *DiscordBotQuery, after, before *Cursor) *DiscordBotQuery {
	for _, predicate := range cursorsToPredicates(
		p.order.Direction, after, before,
		p.order.Field.field, DefaultDiscordBotOrder.Field.field,
	) {
		query = query.Where(predicate)
	}
	return query
}

func (p *discordbotPager) applyOrder(query *DiscordBotQuery, reverse bool) *DiscordBotQuery {
	direction := p.order.Direction
	if reverse {
		direction = direction.reverse()
	}
	query = query.Order(direction.orderFunc(p.order.Field.field))
	if p.order.Field != DefaultDiscordBotOrder.Field {
		query = query.Order(direction.orderFunc(DefaultDiscordBotOrder.Field.field))
	}
	return query
}

func (p *discordbotPager) orderExpr(reverse bool) sql.Querier {
	direction := p.order.Direction
	if reverse {
		direction = direction.reverse()
	}
	return sql.ExprFunc(func(b *sql.Builder) {
		b.Ident(p.order.Field.field).Pad().WriteString(string(direction))
		if p.order.Field != DefaultDiscordBotOrder.Field {
			b.Comma().Ident(DefaultDiscordBotOrder.Field.field).Pad().WriteString(string(direction))
		}
	})
}

// Paginate executes the query and returns a relay based cursor connection to DiscordBot.
func (db *DiscordBotQuery) Paginate(
	ctx context.Context, after *Cursor, first *int,
	before *Cursor, last *int, opts ...DiscordBotPaginateOption,
) (*DiscordBotConnection, error) {
	if err := validateFirstLast(first, last); err != nil {
		return nil, err
	}
	pager, err := newDiscordBotPager(opts)
	if err != nil {
		return nil, err
	}
	if db, err = pager.applyFilter(db); err != nil {
		return nil, err
	}
	conn := &DiscordBotConnection{Edges: []*DiscordBotEdge{}}
	ignoredEdges := !hasCollectedField(ctx, edgesField)
	if hasCollectedField(ctx, totalCountField) || hasCollectedField(ctx, pageInfoField) {
		hasPagination := after != nil || first != nil || before != nil || last != nil
		if hasPagination || ignoredEdges {
			if conn.TotalCount, err = db.Count(ctx); err != nil {
				return nil, err
			}
			conn.PageInfo.HasNextPage = first != nil && conn.TotalCount > 0
			conn.PageInfo.HasPreviousPage = last != nil && conn.TotalCount > 0
		}
	}
	if ignoredEdges || (first != nil && *first == 0) || (last != nil && *last == 0) {
		return conn, nil
	}

	db = pager.applyCursors(db, after, before)
	db = pager.applyOrder(db, last != nil)
	if limit := paginateLimit(first, last); limit != 0 {
		db.Limit(limit)
	}
	if field := collectedField(ctx, edgesField, nodeField); field != nil {
		if err := db.collectField(ctx, graphql.GetOperationContext(ctx), *field, []string{edgesField, nodeField}); err != nil {
			return nil, err
		}
	}

	nodes, err := db.All(ctx)
	if err != nil {
		return nil, err
	}
	conn.build(nodes, pager, after, first, before, last)
	return conn, nil
}

// DiscordBotOrderField defines the ordering field of DiscordBot.
type DiscordBotOrderField struct {
	field    string
	toCursor func(*DiscordBot) Cursor
}

// DiscordBotOrder defines the ordering of DiscordBot.
type DiscordBotOrder struct {
	Direction OrderDirection        `json:"direction"`
	Field     *DiscordBotOrderField `json:"field"`
}

// DefaultDiscordBotOrder is the default ordering of DiscordBot.
var DefaultDiscordBotOrder = &DiscordBotOrder{
	Direction: OrderDirectionAsc,
	Field: &DiscordBotOrderField{
		field: discordbot.FieldID,
		toCursor: func(db *DiscordBot) Cursor {
			return Cursor{ID: db.ID}
		},
	},
}

// ToEdge converts DiscordBot into DiscordBotEdge.
func (db *DiscordBot) ToEdge(order *DiscordBotOrder) *DiscordBotEdge {
	if order == nil {
		order = DefaultDiscordBotOrder
	}
	return &DiscordBotEdge{
		Node:   db,
		Cursor: order.Field.toCursor(db),
	}
}

// GithubAccountEdge is the edge representation of GithubAccount.
type GithubAccountEdge struct {
	Node   *GithubAccount `json:"node"`
	Cursor Cursor         `json:"cursor"`
}

// GithubAccountConnection is the connection containing edges to GithubAccount.
type GithubAccountConnection struct {
	Edges      []*GithubAccountEdge `json:"edges"`
	PageInfo   PageInfo             `json:"pageInfo"`
	TotalCount int                  `json:"totalCount"`
}

func (c *GithubAccountConnection) build(nodes []*GithubAccount, pager *githubaccountPager, after *Cursor, first *int, before *Cursor, last *int) {
	c.PageInfo.HasNextPage = before != nil
	c.PageInfo.HasPreviousPage = after != nil
	if first != nil && *first+1 == len(nodes) {
		c.PageInfo.HasNextPage = true
		nodes = nodes[:len(nodes)-1]
	} else if last != nil && *last+1 == len(nodes) {
		c.PageInfo.HasPreviousPage = true
		nodes = nodes[:len(nodes)-1]
	}
	var nodeAt func(int) *GithubAccount
	if last != nil {
		n := len(nodes) - 1
		nodeAt = func(i int) *GithubAccount {
			return nodes[n-i]
		}
	} else {
		nodeAt = func(i int) *GithubAccount {
			return nodes[i]
		}
	}
	c.Edges = make([]*GithubAccountEdge, len(nodes))
	for i := range nodes {
		node := nodeAt(i)
		c.Edges[i] = &GithubAccountEdge{
			Node:   node,
			Cursor: pager.toCursor(node),
		}
	}
	if l := len(c.Edges); l > 0 {
		c.PageInfo.StartCursor = &c.Edges[0].Cursor
		c.PageInfo.EndCursor = &c.Edges[l-1].Cursor
	}
	if c.TotalCount == 0 {
		c.TotalCount = len(nodes)
	}
}

// GithubAccountPaginateOption enables pagination customization.
type GithubAccountPaginateOption func(*githubaccountPager) error

// WithGithubAccountOrder configures pagination ordering.
func WithGithubAccountOrder(order *GithubAccountOrder) GithubAccountPaginateOption {
	if order == nil {
		order = DefaultGithubAccountOrder
	}
	o := *order
	return func(pager *githubaccountPager) error {
		if err := o.Direction.Validate(); err != nil {
			return err
		}
		if o.Field == nil {
			o.Field = DefaultGithubAccountOrder.Field
		}
		pager.order = &o
		return nil
	}
}

// WithGithubAccountFilter configures pagination filter.
func WithGithubAccountFilter(filter func(*GithubAccountQuery) (*GithubAccountQuery, error)) GithubAccountPaginateOption {
	return func(pager *githubaccountPager) error {
		if filter == nil {
			return errors.New("GithubAccountQuery filter cannot be nil")
		}
		pager.filter = filter
		return nil
	}
}

type githubaccountPager struct {
	order  *GithubAccountOrder
	filter func(*GithubAccountQuery) (*GithubAccountQuery, error)
}

func newGithubAccountPager(opts []GithubAccountPaginateOption) (*githubaccountPager, error) {
	pager := &githubaccountPager{}
	for _, opt := range opts {
		if err := opt(pager); err != nil {
			return nil, err
		}
	}
	if pager.order == nil {
		pager.order = DefaultGithubAccountOrder
	}
	return pager, nil
}

func (p *githubaccountPager) applyFilter(query *GithubAccountQuery) (*GithubAccountQuery, error) {
	if p.filter != nil {
		return p.filter(query)
	}
	return query, nil
}

func (p *githubaccountPager) toCursor(ga *GithubAccount) Cursor {
	return p.order.Field.toCursor(ga)
}

func (p *githubaccountPager) applyCursors(query *GithubAccountQuery, after, before *Cursor) *GithubAccountQuery {
	for _, predicate := range cursorsToPredicates(
		p.order.Direction, after, before,
		p.order.Field.field, DefaultGithubAccountOrder.Field.field,
	) {
		query = query.Where(predicate)
	}
	return query
}

func (p *githubaccountPager) applyOrder(query *GithubAccountQuery, reverse bool) *GithubAccountQuery {
	direction := p.order.Direction
	if reverse {
		direction = direction.reverse()
	}
	query = query.Order(direction.orderFunc(p.order.Field.field))
	if p.order.Field != DefaultGithubAccountOrder.Field {
		query = query.Order(direction.orderFunc(DefaultGithubAccountOrder.Field.field))
	}
	return query
}

func (p *githubaccountPager) orderExpr(reverse bool) sql.Querier {
	direction := p.order.Direction
	if reverse {
		direction = direction.reverse()
	}
	return sql.ExprFunc(func(b *sql.Builder) {
		b.Ident(p.order.Field.field).Pad().WriteString(string(direction))
		if p.order.Field != DefaultGithubAccountOrder.Field {
			b.Comma().Ident(DefaultGithubAccountOrder.Field.field).Pad().WriteString(string(direction))
		}
	})
}

// Paginate executes the query and returns a relay based cursor connection to GithubAccount.
func (ga *GithubAccountQuery) Paginate(
	ctx context.Context, after *Cursor, first *int,
	before *Cursor, last *int, opts ...GithubAccountPaginateOption,
) (*GithubAccountConnection, error) {
	if err := validateFirstLast(first, last); err != nil {
		return nil, err
	}
	pager, err := newGithubAccountPager(opts)
	if err != nil {
		return nil, err
	}
	if ga, err = pager.applyFilter(ga); err != nil {
		return nil, err
	}
	conn := &GithubAccountConnection{Edges: []*GithubAccountEdge{}}
	ignoredEdges := !hasCollectedField(ctx, edgesField)
	if hasCollectedField(ctx, totalCountField) || hasCollectedField(ctx, pageInfoField) {
		hasPagination := after != nil || first != nil || before != nil || last != nil
		if hasPagination || ignoredEdges {
			if conn.TotalCount, err = ga.Count(ctx); err != nil {
				return nil, err
			}
			conn.PageInfo.HasNextPage = first != nil && conn.TotalCount > 0
			conn.PageInfo.HasPreviousPage = last != nil && conn.TotalCount > 0
		}
	}
	if ignoredEdges || (first != nil && *first == 0) || (last != nil && *last == 0) {
		return conn, nil
	}

	ga = pager.applyCursors(ga, after, before)
	ga = pager.applyOrder(ga, last != nil)
	if limit := paginateLimit(first, last); limit != 0 {
		ga.Limit(limit)
	}
	if field := collectedField(ctx, edgesField, nodeField); field != nil {
		if err := ga.collectField(ctx, graphql.GetOperationContext(ctx), *field, []string{edgesField, nodeField}); err != nil {
			return nil, err
		}
	}

	nodes, err := ga.All(ctx)
	if err != nil {
		return nil, err
	}
	conn.build(nodes, pager, after, first, before, last)
	return conn, nil
}

var (
	// GithubAccountOrderFieldUsername orders GithubAccount by username.
	GithubAccountOrderFieldUsername = &GithubAccountOrderField{
		field: githubaccount.FieldUsername,
		toCursor: func(ga *GithubAccount) Cursor {
			return Cursor{
				ID:    ga.ID,
				Value: ga.Username,
			}
		},
	}
)

// String implement fmt.Stringer interface.
func (f GithubAccountOrderField) String() string {
	var str string
	switch f.field {
	case githubaccount.FieldUsername:
		str = "USERNAME"
	}
	return str
}

// MarshalGQL implements graphql.Marshaler interface.
func (f GithubAccountOrderField) MarshalGQL(w io.Writer) {
	io.WriteString(w, strconv.Quote(f.String()))
}

// UnmarshalGQL implements graphql.Unmarshaler interface.
func (f *GithubAccountOrderField) UnmarshalGQL(v interface{}) error {
	str, ok := v.(string)
	if !ok {
		return fmt.Errorf("GithubAccountOrderField %T must be a string", v)
	}
	switch str {
	case "USERNAME":
		*f = *GithubAccountOrderFieldUsername
	default:
		return fmt.Errorf("%s is not a valid GithubAccountOrderField", str)
	}
	return nil
}

// GithubAccountOrderField defines the ordering field of GithubAccount.
type GithubAccountOrderField struct {
	field    string
	toCursor func(*GithubAccount) Cursor
}

// GithubAccountOrder defines the ordering of GithubAccount.
type GithubAccountOrder struct {
	Direction OrderDirection           `json:"direction"`
	Field     *GithubAccountOrderField `json:"field"`
}

// DefaultGithubAccountOrder is the default ordering of GithubAccount.
var DefaultGithubAccountOrder = &GithubAccountOrder{
	Direction: OrderDirectionAsc,
	Field: &GithubAccountOrderField{
		field: githubaccount.FieldID,
		toCursor: func(ga *GithubAccount) Cursor {
			return Cursor{ID: ga.ID}
		},
	},
}

// ToEdge converts GithubAccount into GithubAccountEdge.
func (ga *GithubAccount) ToEdge(order *GithubAccountOrder) *GithubAccountEdge {
	if order == nil {
		order = DefaultGithubAccountOrder
	}
	return &GithubAccountEdge{
		Node:   ga,
		Cursor: order.Field.toCursor(ga),
	}
}

// GithubOrganizationEdge is the edge representation of GithubOrganization.
type GithubOrganizationEdge struct {
	Node   *GithubOrganization `json:"node"`
	Cursor Cursor              `json:"cursor"`
}

// GithubOrganizationConnection is the connection containing edges to GithubOrganization.
type GithubOrganizationConnection struct {
	Edges      []*GithubOrganizationEdge `json:"edges"`
	PageInfo   PageInfo                  `json:"pageInfo"`
	TotalCount int                       `json:"totalCount"`
}

func (c *GithubOrganizationConnection) build(nodes []*GithubOrganization, pager *githuborganizationPager, after *Cursor, first *int, before *Cursor, last *int) {
	c.PageInfo.HasNextPage = before != nil
	c.PageInfo.HasPreviousPage = after != nil
	if first != nil && *first+1 == len(nodes) {
		c.PageInfo.HasNextPage = true
		nodes = nodes[:len(nodes)-1]
	} else if last != nil && *last+1 == len(nodes) {
		c.PageInfo.HasPreviousPage = true
		nodes = nodes[:len(nodes)-1]
	}
	var nodeAt func(int) *GithubOrganization
	if last != nil {
		n := len(nodes) - 1
		nodeAt = func(i int) *GithubOrganization {
			return nodes[n-i]
		}
	} else {
		nodeAt = func(i int) *GithubOrganization {
			return nodes[i]
		}
	}
	c.Edges = make([]*GithubOrganizationEdge, len(nodes))
	for i := range nodes {
		node := nodeAt(i)
		c.Edges[i] = &GithubOrganizationEdge{
			Node:   node,
			Cursor: pager.toCursor(node),
		}
	}
	if l := len(c.Edges); l > 0 {
		c.PageInfo.StartCursor = &c.Edges[0].Cursor
		c.PageInfo.EndCursor = &c.Edges[l-1].Cursor
	}
	if c.TotalCount == 0 {
		c.TotalCount = len(nodes)
	}
}

// GithubOrganizationPaginateOption enables pagination customization.
type GithubOrganizationPaginateOption func(*githuborganizationPager) error

// WithGithubOrganizationOrder configures pagination ordering.
func WithGithubOrganizationOrder(order *GithubOrganizationOrder) GithubOrganizationPaginateOption {
	if order == nil {
		order = DefaultGithubOrganizationOrder
	}
	o := *order
	return func(pager *githuborganizationPager) error {
		if err := o.Direction.Validate(); err != nil {
			return err
		}
		if o.Field == nil {
			o.Field = DefaultGithubOrganizationOrder.Field
		}
		pager.order = &o
		return nil
	}
}

// WithGithubOrganizationFilter configures pagination filter.
func WithGithubOrganizationFilter(filter func(*GithubOrganizationQuery) (*GithubOrganizationQuery, error)) GithubOrganizationPaginateOption {
	return func(pager *githuborganizationPager) error {
		if filter == nil {
			return errors.New("GithubOrganizationQuery filter cannot be nil")
		}
		pager.filter = filter
		return nil
	}
}

type githuborganizationPager struct {
	order  *GithubOrganizationOrder
	filter func(*GithubOrganizationQuery) (*GithubOrganizationQuery, error)
}

func newGithubOrganizationPager(opts []GithubOrganizationPaginateOption) (*githuborganizationPager, error) {
	pager := &githuborganizationPager{}
	for _, opt := range opts {
		if err := opt(pager); err != nil {
			return nil, err
		}
	}
	if pager.order == nil {
		pager.order = DefaultGithubOrganizationOrder
	}
	return pager, nil
}

func (p *githuborganizationPager) applyFilter(query *GithubOrganizationQuery) (*GithubOrganizationQuery, error) {
	if p.filter != nil {
		return p.filter(query)
	}
	return query, nil
}

func (p *githuborganizationPager) toCursor(_go *GithubOrganization) Cursor {
	return p.order.Field.toCursor(_go)
}

func (p *githuborganizationPager) applyCursors(query *GithubOrganizationQuery, after, before *Cursor) *GithubOrganizationQuery {
	for _, predicate := range cursorsToPredicates(
		p.order.Direction, after, before,
		p.order.Field.field, DefaultGithubOrganizationOrder.Field.field,
	) {
		query = query.Where(predicate)
	}
	return query
}

func (p *githuborganizationPager) applyOrder(query *GithubOrganizationQuery, reverse bool) *GithubOrganizationQuery {
	direction := p.order.Direction
	if reverse {
		direction = direction.reverse()
	}
	query = query.Order(direction.orderFunc(p.order.Field.field))
	if p.order.Field != DefaultGithubOrganizationOrder.Field {
		query = query.Order(direction.orderFunc(DefaultGithubOrganizationOrder.Field.field))
	}
	return query
}

func (p *githuborganizationPager) orderExpr(reverse bool) sql.Querier {
	direction := p.order.Direction
	if reverse {
		direction = direction.reverse()
	}
	return sql.ExprFunc(func(b *sql.Builder) {
		b.Ident(p.order.Field.field).Pad().WriteString(string(direction))
		if p.order.Field != DefaultGithubOrganizationOrder.Field {
			b.Comma().Ident(DefaultGithubOrganizationOrder.Field.field).Pad().WriteString(string(direction))
		}
	})
}

// Paginate executes the query and returns a relay based cursor connection to GithubOrganization.
func (_go *GithubOrganizationQuery) Paginate(
	ctx context.Context, after *Cursor, first *int,
	before *Cursor, last *int, opts ...GithubOrganizationPaginateOption,
) (*GithubOrganizationConnection, error) {
	if err := validateFirstLast(first, last); err != nil {
		return nil, err
	}
	pager, err := newGithubOrganizationPager(opts)
	if err != nil {
		return nil, err
	}
	if _go, err = pager.applyFilter(_go); err != nil {
		return nil, err
	}
	conn := &GithubOrganizationConnection{Edges: []*GithubOrganizationEdge{}}
	ignoredEdges := !hasCollectedField(ctx, edgesField)
	if hasCollectedField(ctx, totalCountField) || hasCollectedField(ctx, pageInfoField) {
		hasPagination := after != nil || first != nil || before != nil || last != nil
		if hasPagination || ignoredEdges {
			if conn.TotalCount, err = _go.Count(ctx); err != nil {
				return nil, err
			}
			conn.PageInfo.HasNextPage = first != nil && conn.TotalCount > 0
			conn.PageInfo.HasPreviousPage = last != nil && conn.TotalCount > 0
		}
	}
	if ignoredEdges || (first != nil && *first == 0) || (last != nil && *last == 0) {
		return conn, nil
	}

	_go = pager.applyCursors(_go, after, before)
	_go = pager.applyOrder(_go, last != nil)
	if limit := paginateLimit(first, last); limit != 0 {
		_go.Limit(limit)
	}
	if field := collectedField(ctx, edgesField, nodeField); field != nil {
		if err := _go.collectField(ctx, graphql.GetOperationContext(ctx), *field, []string{edgesField, nodeField}); err != nil {
			return nil, err
		}
	}

	nodes, err := _go.All(ctx)
	if err != nil {
		return nil, err
	}
	conn.build(nodes, pager, after, first, before, last)
	return conn, nil
}

var (
	// GithubOrganizationOrderFieldName orders GithubOrganization by name.
	GithubOrganizationOrderFieldName = &GithubOrganizationOrderField{
		field: githuborganization.FieldName,
		toCursor: func(_go *GithubOrganization) Cursor {
			return Cursor{
				ID:    _go.ID,
				Value: _go.Name,
			}
		},
	}
	// GithubOrganizationOrderFieldDisplayName orders GithubOrganization by display_name.
	GithubOrganizationOrderFieldDisplayName = &GithubOrganizationOrderField{
		field: githuborganization.FieldDisplayName,
		toCursor: func(_go *GithubOrganization) Cursor {
			return Cursor{
				ID:    _go.ID,
				Value: _go.DisplayName,
			}
		},
	}
)

// String implement fmt.Stringer interface.
func (f GithubOrganizationOrderField) String() string {
	var str string
	switch f.field {
	case githuborganization.FieldName:
		str = "NAME"
	case githuborganization.FieldDisplayName:
		str = "DISPLAY_NAME"
	}
	return str
}

// MarshalGQL implements graphql.Marshaler interface.
func (f GithubOrganizationOrderField) MarshalGQL(w io.Writer) {
	io.WriteString(w, strconv.Quote(f.String()))
}

// UnmarshalGQL implements graphql.Unmarshaler interface.
func (f *GithubOrganizationOrderField) UnmarshalGQL(v interface{}) error {
	str, ok := v.(string)
	if !ok {
		return fmt.Errorf("GithubOrganizationOrderField %T must be a string", v)
	}
	switch str {
	case "NAME":
		*f = *GithubOrganizationOrderFieldName
	case "DISPLAY_NAME":
		*f = *GithubOrganizationOrderFieldDisplayName
	default:
		return fmt.Errorf("%s is not a valid GithubOrganizationOrderField", str)
	}
	return nil
}

// GithubOrganizationOrderField defines the ordering field of GithubOrganization.
type GithubOrganizationOrderField struct {
	field    string
	toCursor func(*GithubOrganization) Cursor
}

// GithubOrganizationOrder defines the ordering of GithubOrganization.
type GithubOrganizationOrder struct {
	Direction OrderDirection                `json:"direction"`
	Field     *GithubOrganizationOrderField `json:"field"`
}

// DefaultGithubOrganizationOrder is the default ordering of GithubOrganization.
var DefaultGithubOrganizationOrder = &GithubOrganizationOrder{
	Direction: OrderDirectionAsc,
	Field: &GithubOrganizationOrderField{
		field: githuborganization.FieldID,
		toCursor: func(_go *GithubOrganization) Cursor {
			return Cursor{ID: _go.ID}
		},
	},
}

// ToEdge converts GithubOrganization into GithubOrganizationEdge.
func (_go *GithubOrganization) ToEdge(order *GithubOrganizationOrder) *GithubOrganizationEdge {
	if order == nil {
		order = DefaultGithubOrganizationOrder
	}
	return &GithubOrganizationEdge{
		Node:   _go,
		Cursor: order.Field.toCursor(_go),
	}
}

// GithubOrganizationMemberEdge is the edge representation of GithubOrganizationMember.
type GithubOrganizationMemberEdge struct {
	Node   *GithubOrganizationMember `json:"node"`
	Cursor Cursor                    `json:"cursor"`
}

// GithubOrganizationMemberConnection is the connection containing edges to GithubOrganizationMember.
type GithubOrganizationMemberConnection struct {
	Edges      []*GithubOrganizationMemberEdge `json:"edges"`
	PageInfo   PageInfo                        `json:"pageInfo"`
	TotalCount int                             `json:"totalCount"`
}

func (c *GithubOrganizationMemberConnection) build(nodes []*GithubOrganizationMember, pager *githuborganizationmemberPager, after *Cursor, first *int, before *Cursor, last *int) {
	c.PageInfo.HasNextPage = before != nil
	c.PageInfo.HasPreviousPage = after != nil
	if first != nil && *first+1 == len(nodes) {
		c.PageInfo.HasNextPage = true
		nodes = nodes[:len(nodes)-1]
	} else if last != nil && *last+1 == len(nodes) {
		c.PageInfo.HasPreviousPage = true
		nodes = nodes[:len(nodes)-1]
	}
	var nodeAt func(int) *GithubOrganizationMember
	if last != nil {
		n := len(nodes) - 1
		nodeAt = func(i int) *GithubOrganizationMember {
			return nodes[n-i]
		}
	} else {
		nodeAt = func(i int) *GithubOrganizationMember {
			return nodes[i]
		}
	}
	c.Edges = make([]*GithubOrganizationMemberEdge, len(nodes))
	for i := range nodes {
		node := nodeAt(i)
		c.Edges[i] = &GithubOrganizationMemberEdge{
			Node:   node,
			Cursor: pager.toCursor(node),
		}
	}
	if l := len(c.Edges); l > 0 {
		c.PageInfo.StartCursor = &c.Edges[0].Cursor
		c.PageInfo.EndCursor = &c.Edges[l-1].Cursor
	}
	if c.TotalCount == 0 {
		c.TotalCount = len(nodes)
	}
}

// GithubOrganizationMemberPaginateOption enables pagination customization.
type GithubOrganizationMemberPaginateOption func(*githuborganizationmemberPager) error

// WithGithubOrganizationMemberOrder configures pagination ordering.
func WithGithubOrganizationMemberOrder(order *GithubOrganizationMemberOrder) GithubOrganizationMemberPaginateOption {
	if order == nil {
		order = DefaultGithubOrganizationMemberOrder
	}
	o := *order
	return func(pager *githuborganizationmemberPager) error {
		if err := o.Direction.Validate(); err != nil {
			return err
		}
		if o.Field == nil {
			o.Field = DefaultGithubOrganizationMemberOrder.Field
		}
		pager.order = &o
		return nil
	}
}

// WithGithubOrganizationMemberFilter configures pagination filter.
func WithGithubOrganizationMemberFilter(filter func(*GithubOrganizationMemberQuery) (*GithubOrganizationMemberQuery, error)) GithubOrganizationMemberPaginateOption {
	return func(pager *githuborganizationmemberPager) error {
		if filter == nil {
			return errors.New("GithubOrganizationMemberQuery filter cannot be nil")
		}
		pager.filter = filter
		return nil
	}
}

type githuborganizationmemberPager struct {
	order  *GithubOrganizationMemberOrder
	filter func(*GithubOrganizationMemberQuery) (*GithubOrganizationMemberQuery, error)
}

func newGithubOrganizationMemberPager(opts []GithubOrganizationMemberPaginateOption) (*githuborganizationmemberPager, error) {
	pager := &githuborganizationmemberPager{}
	for _, opt := range opts {
		if err := opt(pager); err != nil {
			return nil, err
		}
	}
	if pager.order == nil {
		pager.order = DefaultGithubOrganizationMemberOrder
	}
	return pager, nil
}

func (p *githuborganizationmemberPager) applyFilter(query *GithubOrganizationMemberQuery) (*GithubOrganizationMemberQuery, error) {
	if p.filter != nil {
		return p.filter(query)
	}
	return query, nil
}

func (p *githuborganizationmemberPager) toCursor(gom *GithubOrganizationMember) Cursor {
	return p.order.Field.toCursor(gom)
}

func (p *githuborganizationmemberPager) applyCursors(query *GithubOrganizationMemberQuery, after, before *Cursor) *GithubOrganizationMemberQuery {
	for _, predicate := range cursorsToPredicates(
		p.order.Direction, after, before,
		p.order.Field.field, DefaultGithubOrganizationMemberOrder.Field.field,
	) {
		query = query.Where(predicate)
	}
	return query
}

func (p *githuborganizationmemberPager) applyOrder(query *GithubOrganizationMemberQuery, reverse bool) *GithubOrganizationMemberQuery {
	direction := p.order.Direction
	if reverse {
		direction = direction.reverse()
	}
	query = query.Order(direction.orderFunc(p.order.Field.field))
	if p.order.Field != DefaultGithubOrganizationMemberOrder.Field {
		query = query.Order(direction.orderFunc(DefaultGithubOrganizationMemberOrder.Field.field))
	}
	return query
}

func (p *githuborganizationmemberPager) orderExpr(reverse bool) sql.Querier {
	direction := p.order.Direction
	if reverse {
		direction = direction.reverse()
	}
	return sql.ExprFunc(func(b *sql.Builder) {
		b.Ident(p.order.Field.field).Pad().WriteString(string(direction))
		if p.order.Field != DefaultGithubOrganizationMemberOrder.Field {
			b.Comma().Ident(DefaultGithubOrganizationMemberOrder.Field.field).Pad().WriteString(string(direction))
		}
	})
}

// Paginate executes the query and returns a relay based cursor connection to GithubOrganizationMember.
func (gom *GithubOrganizationMemberQuery) Paginate(
	ctx context.Context, after *Cursor, first *int,
	before *Cursor, last *int, opts ...GithubOrganizationMemberPaginateOption,
) (*GithubOrganizationMemberConnection, error) {
	if err := validateFirstLast(first, last); err != nil {
		return nil, err
	}
	pager, err := newGithubOrganizationMemberPager(opts)
	if err != nil {
		return nil, err
	}
	if gom, err = pager.applyFilter(gom); err != nil {
		return nil, err
	}
	conn := &GithubOrganizationMemberConnection{Edges: []*GithubOrganizationMemberEdge{}}
	ignoredEdges := !hasCollectedField(ctx, edgesField)
	if hasCollectedField(ctx, totalCountField) || hasCollectedField(ctx, pageInfoField) {
		hasPagination := after != nil || first != nil || before != nil || last != nil
		if hasPagination || ignoredEdges {
			if conn.TotalCount, err = gom.Count(ctx); err != nil {
				return nil, err
			}
			conn.PageInfo.HasNextPage = first != nil && conn.TotalCount > 0
			conn.PageInfo.HasPreviousPage = last != nil && conn.TotalCount > 0
		}
	}
	if ignoredEdges || (first != nil && *first == 0) || (last != nil && *last == 0) {
		return conn, nil
	}

	gom = pager.applyCursors(gom, after, before)
	gom = pager.applyOrder(gom, last != nil)
	if limit := paginateLimit(first, last); limit != 0 {
		gom.Limit(limit)
	}
	if field := collectedField(ctx, edgesField, nodeField); field != nil {
		if err := gom.collectField(ctx, graphql.GetOperationContext(ctx), *field, []string{edgesField, nodeField}); err != nil {
			return nil, err
		}
	}

	nodes, err := gom.All(ctx)
	if err != nil {
		return nil, err
	}
	conn.build(nodes, pager, after, first, before, last)
	return conn, nil
}

var (
	// GithubOrganizationMemberOrderFieldRole orders GithubOrganizationMember by role.
	GithubOrganizationMemberOrderFieldRole = &GithubOrganizationMemberOrderField{
		field: githuborganizationmember.FieldRole,
		toCursor: func(gom *GithubOrganizationMember) Cursor {
			return Cursor{
				ID:    gom.ID,
				Value: gom.Role,
			}
		},
	}
)

// String implement fmt.Stringer interface.
func (f GithubOrganizationMemberOrderField) String() string {
	var str string
	switch f.field {
	case githuborganizationmember.FieldRole:
		str = "ROLE"
	}
	return str
}

// MarshalGQL implements graphql.Marshaler interface.
func (f GithubOrganizationMemberOrderField) MarshalGQL(w io.Writer) {
	io.WriteString(w, strconv.Quote(f.String()))
}

// UnmarshalGQL implements graphql.Unmarshaler interface.
func (f *GithubOrganizationMemberOrderField) UnmarshalGQL(v interface{}) error {
	str, ok := v.(string)
	if !ok {
		return fmt.Errorf("GithubOrganizationMemberOrderField %T must be a string", v)
	}
	switch str {
	case "ROLE":
		*f = *GithubOrganizationMemberOrderFieldRole
	default:
		return fmt.Errorf("%s is not a valid GithubOrganizationMemberOrderField", str)
	}
	return nil
}

// GithubOrganizationMemberOrderField defines the ordering field of GithubOrganizationMember.
type GithubOrganizationMemberOrderField struct {
	field    string
	toCursor func(*GithubOrganizationMember) Cursor
}

// GithubOrganizationMemberOrder defines the ordering of GithubOrganizationMember.
type GithubOrganizationMemberOrder struct {
	Direction OrderDirection                      `json:"direction"`
	Field     *GithubOrganizationMemberOrderField `json:"field"`
}

// DefaultGithubOrganizationMemberOrder is the default ordering of GithubOrganizationMember.
var DefaultGithubOrganizationMemberOrder = &GithubOrganizationMemberOrder{
	Direction: OrderDirectionAsc,
	Field: &GithubOrganizationMemberOrderField{
		field: githuborganizationmember.FieldID,
		toCursor: func(gom *GithubOrganizationMember) Cursor {
			return Cursor{ID: gom.ID}
		},
	},
}

// ToEdge converts GithubOrganizationMember into GithubOrganizationMemberEdge.
func (gom *GithubOrganizationMember) ToEdge(order *GithubOrganizationMemberOrder) *GithubOrganizationMemberEdge {
	if order == nil {
		order = DefaultGithubOrganizationMemberOrder
	}
	return &GithubOrganizationMemberEdge{
		Node:   gom,
		Cursor: order.Field.toCursor(gom),
	}
}

// ProjectEdge is the edge representation of Project.
type ProjectEdge struct {
	Node   *Project `json:"node"`
	Cursor Cursor   `json:"cursor"`
}

// ProjectConnection is the connection containing edges to Project.
type ProjectConnection struct {
	Edges      []*ProjectEdge `json:"edges"`
	PageInfo   PageInfo       `json:"pageInfo"`
	TotalCount int            `json:"totalCount"`
}

func (c *ProjectConnection) build(nodes []*Project, pager *projectPager, after *Cursor, first *int, before *Cursor, last *int) {
	c.PageInfo.HasNextPage = before != nil
	c.PageInfo.HasPreviousPage = after != nil
	if first != nil && *first+1 == len(nodes) {
		c.PageInfo.HasNextPage = true
		nodes = nodes[:len(nodes)-1]
	} else if last != nil && *last+1 == len(nodes) {
		c.PageInfo.HasPreviousPage = true
		nodes = nodes[:len(nodes)-1]
	}
	var nodeAt func(int) *Project
	if last != nil {
		n := len(nodes) - 1
		nodeAt = func(i int) *Project {
			return nodes[n-i]
		}
	} else {
		nodeAt = func(i int) *Project {
			return nodes[i]
		}
	}
	c.Edges = make([]*ProjectEdge, len(nodes))
	for i := range nodes {
		node := nodeAt(i)
		c.Edges[i] = &ProjectEdge{
			Node:   node,
			Cursor: pager.toCursor(node),
		}
	}
	if l := len(c.Edges); l > 0 {
		c.PageInfo.StartCursor = &c.Edges[0].Cursor
		c.PageInfo.EndCursor = &c.Edges[l-1].Cursor
	}
	if c.TotalCount == 0 {
		c.TotalCount = len(nodes)
	}
}

// ProjectPaginateOption enables pagination customization.
type ProjectPaginateOption func(*projectPager) error

// WithProjectOrder configures pagination ordering.
func WithProjectOrder(order *ProjectOrder) ProjectPaginateOption {
	if order == nil {
		order = DefaultProjectOrder
	}
	o := *order
	return func(pager *projectPager) error {
		if err := o.Direction.Validate(); err != nil {
			return err
		}
		if o.Field == nil {
			o.Field = DefaultProjectOrder.Field
		}
		pager.order = &o
		return nil
	}
}

// WithProjectFilter configures pagination filter.
func WithProjectFilter(filter func(*ProjectQuery) (*ProjectQuery, error)) ProjectPaginateOption {
	return func(pager *projectPager) error {
		if filter == nil {
			return errors.New("ProjectQuery filter cannot be nil")
		}
		pager.filter = filter
		return nil
	}
}

type projectPager struct {
	order  *ProjectOrder
	filter func(*ProjectQuery) (*ProjectQuery, error)
}

func newProjectPager(opts []ProjectPaginateOption) (*projectPager, error) {
	pager := &projectPager{}
	for _, opt := range opts {
		if err := opt(pager); err != nil {
			return nil, err
		}
	}
	if pager.order == nil {
		pager.order = DefaultProjectOrder
	}
	return pager, nil
}

func (p *projectPager) applyFilter(query *ProjectQuery) (*ProjectQuery, error) {
	if p.filter != nil {
		return p.filter(query)
	}
	return query, nil
}

func (p *projectPager) toCursor(pr *Project) Cursor {
	return p.order.Field.toCursor(pr)
}

func (p *projectPager) applyCursors(query *ProjectQuery, after, before *Cursor) *ProjectQuery {
	for _, predicate := range cursorsToPredicates(
		p.order.Direction, after, before,
		p.order.Field.field, DefaultProjectOrder.Field.field,
	) {
		query = query.Where(predicate)
	}
	return query
}

func (p *projectPager) applyOrder(query *ProjectQuery, reverse bool) *ProjectQuery {
	direction := p.order.Direction
	if reverse {
		direction = direction.reverse()
	}
	query = query.Order(direction.orderFunc(p.order.Field.field))
	if p.order.Field != DefaultProjectOrder.Field {
		query = query.Order(direction.orderFunc(DefaultProjectOrder.Field.field))
	}
	return query
}

func (p *projectPager) orderExpr(reverse bool) sql.Querier {
	direction := p.order.Direction
	if reverse {
		direction = direction.reverse()
	}
	return sql.ExprFunc(func(b *sql.Builder) {
		b.Ident(p.order.Field.field).Pad().WriteString(string(direction))
		if p.order.Field != DefaultProjectOrder.Field {
			b.Comma().Ident(DefaultProjectOrder.Field.field).Pad().WriteString(string(direction))
		}
	})
}

// Paginate executes the query and returns a relay based cursor connection to Project.
func (pr *ProjectQuery) Paginate(
	ctx context.Context, after *Cursor, first *int,
	before *Cursor, last *int, opts ...ProjectPaginateOption,
) (*ProjectConnection, error) {
	if err := validateFirstLast(first, last); err != nil {
		return nil, err
	}
	pager, err := newProjectPager(opts)
	if err != nil {
		return nil, err
	}
	if pr, err = pager.applyFilter(pr); err != nil {
		return nil, err
	}
	conn := &ProjectConnection{Edges: []*ProjectEdge{}}
	ignoredEdges := !hasCollectedField(ctx, edgesField)
	if hasCollectedField(ctx, totalCountField) || hasCollectedField(ctx, pageInfoField) {
		hasPagination := after != nil || first != nil || before != nil || last != nil
		if hasPagination || ignoredEdges {
			if conn.TotalCount, err = pr.Count(ctx); err != nil {
				return nil, err
			}
			conn.PageInfo.HasNextPage = first != nil && conn.TotalCount > 0
			conn.PageInfo.HasPreviousPage = last != nil && conn.TotalCount > 0
		}
	}
	if ignoredEdges || (first != nil && *first == 0) || (last != nil && *last == 0) {
		return conn, nil
	}

	pr = pager.applyCursors(pr, after, before)
	pr = pager.applyOrder(pr, last != nil)
	if limit := paginateLimit(first, last); limit != 0 {
		pr.Limit(limit)
	}
	if field := collectedField(ctx, edgesField, nodeField); field != nil {
		if err := pr.collectField(ctx, graphql.GetOperationContext(ctx), *field, []string{edgesField, nodeField}); err != nil {
			return nil, err
		}
	}

	nodes, err := pr.All(ctx)
	if err != nil {
		return nil, err
	}
	conn.build(nodes, pager, after, first, before, last)
	return conn, nil
}

var (
	// ProjectOrderFieldName orders Project by name.
	ProjectOrderFieldName = &ProjectOrderField{
		field: project.FieldName,
		toCursor: func(pr *Project) Cursor {
			return Cursor{
				ID:    pr.ID,
				Value: pr.Name,
			}
		},
	}
	// ProjectOrderFieldDescription orders Project by description.
	ProjectOrderFieldDescription = &ProjectOrderField{
		field: project.FieldDescription,
		toCursor: func(pr *Project) Cursor {
			return Cursor{
				ID:    pr.ID,
				Value: pr.Description,
			}
		},
	}
	// ProjectOrderFieldStartDate orders Project by start_date.
	ProjectOrderFieldStartDate = &ProjectOrderField{
		field: project.FieldStartDate,
		toCursor: func(pr *Project) Cursor {
			return Cursor{
				ID:    pr.ID,
				Value: pr.StartDate,
			}
		},
	}
	// ProjectOrderFieldEndDate orders Project by end_date.
	ProjectOrderFieldEndDate = &ProjectOrderField{
		field: project.FieldEndDate,
		toCursor: func(pr *Project) Cursor {
			return Cursor{
				ID:    pr.ID,
				Value: pr.EndDate,
			}
		},
	}
)

// String implement fmt.Stringer interface.
func (f ProjectOrderField) String() string {
	var str string
	switch f.field {
	case project.FieldName:
		str = "NAME"
	case project.FieldDescription:
		str = "DESCRIPTION"
	case project.FieldStartDate:
		str = "START_DATE"
	case project.FieldEndDate:
		str = "END_DATE"
	}
	return str
}

// MarshalGQL implements graphql.Marshaler interface.
func (f ProjectOrderField) MarshalGQL(w io.Writer) {
	io.WriteString(w, strconv.Quote(f.String()))
}

// UnmarshalGQL implements graphql.Unmarshaler interface.
func (f *ProjectOrderField) UnmarshalGQL(v interface{}) error {
	str, ok := v.(string)
	if !ok {
		return fmt.Errorf("ProjectOrderField %T must be a string", v)
	}
	switch str {
	case "NAME":
		*f = *ProjectOrderFieldName
	case "DESCRIPTION":
		*f = *ProjectOrderFieldDescription
	case "START_DATE":
		*f = *ProjectOrderFieldStartDate
	case "END_DATE":
		*f = *ProjectOrderFieldEndDate
	default:
		return fmt.Errorf("%s is not a valid ProjectOrderField", str)
	}
	return nil
}

// ProjectOrderField defines the ordering field of Project.
type ProjectOrderField struct {
	field    string
	toCursor func(*Project) Cursor
}

// ProjectOrder defines the ordering of Project.
type ProjectOrder struct {
	Direction OrderDirection     `json:"direction"`
	Field     *ProjectOrderField `json:"field"`
}

// DefaultProjectOrder is the default ordering of Project.
var DefaultProjectOrder = &ProjectOrder{
	Direction: OrderDirectionAsc,
	Field: &ProjectOrderField{
		field: project.FieldID,
		toCursor: func(pr *Project) Cursor {
			return Cursor{ID: pr.ID}
		},
	},
}

// ToEdge converts Project into ProjectEdge.
func (pr *Project) ToEdge(order *ProjectOrder) *ProjectEdge {
	if order == nil {
		order = DefaultProjectOrder
	}
	return &ProjectEdge{
		Node:   pr,
		Cursor: order.Field.toCursor(pr),
	}
}

// ProjectAssociationEdge is the edge representation of ProjectAssociation.
type ProjectAssociationEdge struct {
	Node   *ProjectAssociation `json:"node"`
	Cursor Cursor              `json:"cursor"`
}

// ProjectAssociationConnection is the connection containing edges to ProjectAssociation.
type ProjectAssociationConnection struct {
	Edges      []*ProjectAssociationEdge `json:"edges"`
	PageInfo   PageInfo                  `json:"pageInfo"`
	TotalCount int                       `json:"totalCount"`
}

func (c *ProjectAssociationConnection) build(nodes []*ProjectAssociation, pager *projectassociationPager, after *Cursor, first *int, before *Cursor, last *int) {
	c.PageInfo.HasNextPage = before != nil
	c.PageInfo.HasPreviousPage = after != nil
	if first != nil && *first+1 == len(nodes) {
		c.PageInfo.HasNextPage = true
		nodes = nodes[:len(nodes)-1]
	} else if last != nil && *last+1 == len(nodes) {
		c.PageInfo.HasPreviousPage = true
		nodes = nodes[:len(nodes)-1]
	}
	var nodeAt func(int) *ProjectAssociation
	if last != nil {
		n := len(nodes) - 1
		nodeAt = func(i int) *ProjectAssociation {
			return nodes[n-i]
		}
	} else {
		nodeAt = func(i int) *ProjectAssociation {
			return nodes[i]
		}
	}
	c.Edges = make([]*ProjectAssociationEdge, len(nodes))
	for i := range nodes {
		node := nodeAt(i)
		c.Edges[i] = &ProjectAssociationEdge{
			Node:   node,
			Cursor: pager.toCursor(node),
		}
	}
	if l := len(c.Edges); l > 0 {
		c.PageInfo.StartCursor = &c.Edges[0].Cursor
		c.PageInfo.EndCursor = &c.Edges[l-1].Cursor
	}
	if c.TotalCount == 0 {
		c.TotalCount = len(nodes)
	}
}

// ProjectAssociationPaginateOption enables pagination customization.
type ProjectAssociationPaginateOption func(*projectassociationPager) error

// WithProjectAssociationOrder configures pagination ordering.
func WithProjectAssociationOrder(order *ProjectAssociationOrder) ProjectAssociationPaginateOption {
	if order == nil {
		order = DefaultProjectAssociationOrder
	}
	o := *order
	return func(pager *projectassociationPager) error {
		if err := o.Direction.Validate(); err != nil {
			return err
		}
		if o.Field == nil {
			o.Field = DefaultProjectAssociationOrder.Field
		}
		pager.order = &o
		return nil
	}
}

// WithProjectAssociationFilter configures pagination filter.
func WithProjectAssociationFilter(filter func(*ProjectAssociationQuery) (*ProjectAssociationQuery, error)) ProjectAssociationPaginateOption {
	return func(pager *projectassociationPager) error {
		if filter == nil {
			return errors.New("ProjectAssociationQuery filter cannot be nil")
		}
		pager.filter = filter
		return nil
	}
}

type projectassociationPager struct {
	order  *ProjectAssociationOrder
	filter func(*ProjectAssociationQuery) (*ProjectAssociationQuery, error)
}

func newProjectAssociationPager(opts []ProjectAssociationPaginateOption) (*projectassociationPager, error) {
	pager := &projectassociationPager{}
	for _, opt := range opts {
		if err := opt(pager); err != nil {
			return nil, err
		}
	}
	if pager.order == nil {
		pager.order = DefaultProjectAssociationOrder
	}
	return pager, nil
}

func (p *projectassociationPager) applyFilter(query *ProjectAssociationQuery) (*ProjectAssociationQuery, error) {
	if p.filter != nil {
		return p.filter(query)
	}
	return query, nil
}

func (p *projectassociationPager) toCursor(pa *ProjectAssociation) Cursor {
	return p.order.Field.toCursor(pa)
}

func (p *projectassociationPager) applyCursors(query *ProjectAssociationQuery, after, before *Cursor) *ProjectAssociationQuery {
	for _, predicate := range cursorsToPredicates(
		p.order.Direction, after, before,
		p.order.Field.field, DefaultProjectAssociationOrder.Field.field,
	) {
		query = query.Where(predicate)
	}
	return query
}

func (p *projectassociationPager) applyOrder(query *ProjectAssociationQuery, reverse bool) *ProjectAssociationQuery {
	direction := p.order.Direction
	if reverse {
		direction = direction.reverse()
	}
	query = query.Order(direction.orderFunc(p.order.Field.field))
	if p.order.Field != DefaultProjectAssociationOrder.Field {
		query = query.Order(direction.orderFunc(DefaultProjectAssociationOrder.Field.field))
	}
	return query
}

func (p *projectassociationPager) orderExpr(reverse bool) sql.Querier {
	direction := p.order.Direction
	if reverse {
		direction = direction.reverse()
	}
	return sql.ExprFunc(func(b *sql.Builder) {
		b.Ident(p.order.Field.field).Pad().WriteString(string(direction))
		if p.order.Field != DefaultProjectAssociationOrder.Field {
			b.Comma().Ident(DefaultProjectAssociationOrder.Field.field).Pad().WriteString(string(direction))
		}
	})
}

// Paginate executes the query and returns a relay based cursor connection to ProjectAssociation.
func (pa *ProjectAssociationQuery) Paginate(
	ctx context.Context, after *Cursor, first *int,
	before *Cursor, last *int, opts ...ProjectAssociationPaginateOption,
) (*ProjectAssociationConnection, error) {
	if err := validateFirstLast(first, last); err != nil {
		return nil, err
	}
	pager, err := newProjectAssociationPager(opts)
	if err != nil {
		return nil, err
	}
	if pa, err = pager.applyFilter(pa); err != nil {
		return nil, err
	}
	conn := &ProjectAssociationConnection{Edges: []*ProjectAssociationEdge{}}
	ignoredEdges := !hasCollectedField(ctx, edgesField)
	if hasCollectedField(ctx, totalCountField) || hasCollectedField(ctx, pageInfoField) {
		hasPagination := after != nil || first != nil || before != nil || last != nil
		if hasPagination || ignoredEdges {
			if conn.TotalCount, err = pa.Count(ctx); err != nil {
				return nil, err
			}
			conn.PageInfo.HasNextPage = first != nil && conn.TotalCount > 0
			conn.PageInfo.HasPreviousPage = last != nil && conn.TotalCount > 0
		}
	}
	if ignoredEdges || (first != nil && *first == 0) || (last != nil && *last == 0) {
		return conn, nil
	}

	pa = pager.applyCursors(pa, after, before)
	pa = pager.applyOrder(pa, last != nil)
	if limit := paginateLimit(first, last); limit != 0 {
		pa.Limit(limit)
	}
	if field := collectedField(ctx, edgesField, nodeField); field != nil {
		if err := pa.collectField(ctx, graphql.GetOperationContext(ctx), *field, []string{edgesField, nodeField}); err != nil {
			return nil, err
		}
	}

	nodes, err := pa.All(ctx)
	if err != nil {
		return nil, err
	}
	conn.build(nodes, pager, after, first, before, last)
	return conn, nil
}

var (
	// ProjectAssociationOrderFieldType orders ProjectAssociation by type.
	ProjectAssociationOrderFieldType = &ProjectAssociationOrderField{
		field: projectassociation.FieldType,
		toCursor: func(pa *ProjectAssociation) Cursor {
			return Cursor{
				ID:    pa.ID,
				Value: pa.Type,
			}
		},
	}
)

// String implement fmt.Stringer interface.
func (f ProjectAssociationOrderField) String() string {
	var str string
	switch f.field {
	case projectassociation.FieldType:
		str = "TYPE"
	}
	return str
}

// MarshalGQL implements graphql.Marshaler interface.
func (f ProjectAssociationOrderField) MarshalGQL(w io.Writer) {
	io.WriteString(w, strconv.Quote(f.String()))
}

// UnmarshalGQL implements graphql.Unmarshaler interface.
func (f *ProjectAssociationOrderField) UnmarshalGQL(v interface{}) error {
	str, ok := v.(string)
	if !ok {
		return fmt.Errorf("ProjectAssociationOrderField %T must be a string", v)
	}
	switch str {
	case "TYPE":
		*f = *ProjectAssociationOrderFieldType
	default:
		return fmt.Errorf("%s is not a valid ProjectAssociationOrderField", str)
	}
	return nil
}

// ProjectAssociationOrderField defines the ordering field of ProjectAssociation.
type ProjectAssociationOrderField struct {
	field    string
	toCursor func(*ProjectAssociation) Cursor
}

// ProjectAssociationOrder defines the ordering of ProjectAssociation.
type ProjectAssociationOrder struct {
	Direction OrderDirection                `json:"direction"`
	Field     *ProjectAssociationOrderField `json:"field"`
}

// DefaultProjectAssociationOrder is the default ordering of ProjectAssociation.
var DefaultProjectAssociationOrder = &ProjectAssociationOrder{
	Direction: OrderDirectionAsc,
	Field: &ProjectAssociationOrderField{
		field: projectassociation.FieldID,
		toCursor: func(pa *ProjectAssociation) Cursor {
			return Cursor{ID: pa.ID}
		},
	},
}

// ToEdge converts ProjectAssociation into ProjectAssociationEdge.
func (pa *ProjectAssociation) ToEdge(order *ProjectAssociationOrder) *ProjectAssociationEdge {
	if order == nil {
		order = DefaultProjectAssociationOrder
	}
	return &ProjectAssociationEdge{
		Node:   pa,
		Cursor: order.Field.toCursor(pa),
	}
}

// ProjectContributorEdge is the edge representation of ProjectContributor.
type ProjectContributorEdge struct {
	Node   *ProjectContributor `json:"node"`
	Cursor Cursor              `json:"cursor"`
}

// ProjectContributorConnection is the connection containing edges to ProjectContributor.
type ProjectContributorConnection struct {
	Edges      []*ProjectContributorEdge `json:"edges"`
	PageInfo   PageInfo                  `json:"pageInfo"`
	TotalCount int                       `json:"totalCount"`
}

func (c *ProjectContributorConnection) build(nodes []*ProjectContributor, pager *projectcontributorPager, after *Cursor, first *int, before *Cursor, last *int) {
	c.PageInfo.HasNextPage = before != nil
	c.PageInfo.HasPreviousPage = after != nil
	if first != nil && *first+1 == len(nodes) {
		c.PageInfo.HasNextPage = true
		nodes = nodes[:len(nodes)-1]
	} else if last != nil && *last+1 == len(nodes) {
		c.PageInfo.HasPreviousPage = true
		nodes = nodes[:len(nodes)-1]
	}
	var nodeAt func(int) *ProjectContributor
	if last != nil {
		n := len(nodes) - 1
		nodeAt = func(i int) *ProjectContributor {
			return nodes[n-i]
		}
	} else {
		nodeAt = func(i int) *ProjectContributor {
			return nodes[i]
		}
	}
	c.Edges = make([]*ProjectContributorEdge, len(nodes))
	for i := range nodes {
		node := nodeAt(i)
		c.Edges[i] = &ProjectContributorEdge{
			Node:   node,
			Cursor: pager.toCursor(node),
		}
	}
	if l := len(c.Edges); l > 0 {
		c.PageInfo.StartCursor = &c.Edges[0].Cursor
		c.PageInfo.EndCursor = &c.Edges[l-1].Cursor
	}
	if c.TotalCount == 0 {
		c.TotalCount = len(nodes)
	}
}

// ProjectContributorPaginateOption enables pagination customization.
type ProjectContributorPaginateOption func(*projectcontributorPager) error

// WithProjectContributorOrder configures pagination ordering.
func WithProjectContributorOrder(order *ProjectContributorOrder) ProjectContributorPaginateOption {
	if order == nil {
		order = DefaultProjectContributorOrder
	}
	o := *order
	return func(pager *projectcontributorPager) error {
		if err := o.Direction.Validate(); err != nil {
			return err
		}
		if o.Field == nil {
			o.Field = DefaultProjectContributorOrder.Field
		}
		pager.order = &o
		return nil
	}
}

// WithProjectContributorFilter configures pagination filter.
func WithProjectContributorFilter(filter func(*ProjectContributorQuery) (*ProjectContributorQuery, error)) ProjectContributorPaginateOption {
	return func(pager *projectcontributorPager) error {
		if filter == nil {
			return errors.New("ProjectContributorQuery filter cannot be nil")
		}
		pager.filter = filter
		return nil
	}
}

type projectcontributorPager struct {
	order  *ProjectContributorOrder
	filter func(*ProjectContributorQuery) (*ProjectContributorQuery, error)
}

func newProjectContributorPager(opts []ProjectContributorPaginateOption) (*projectcontributorPager, error) {
	pager := &projectcontributorPager{}
	for _, opt := range opts {
		if err := opt(pager); err != nil {
			return nil, err
		}
	}
	if pager.order == nil {
		pager.order = DefaultProjectContributorOrder
	}
	return pager, nil
}

func (p *projectcontributorPager) applyFilter(query *ProjectContributorQuery) (*ProjectContributorQuery, error) {
	if p.filter != nil {
		return p.filter(query)
	}
	return query, nil
}

func (p *projectcontributorPager) toCursor(pc *ProjectContributor) Cursor {
	return p.order.Field.toCursor(pc)
}

func (p *projectcontributorPager) applyCursors(query *ProjectContributorQuery, after, before *Cursor) *ProjectContributorQuery {
	for _, predicate := range cursorsToPredicates(
		p.order.Direction, after, before,
		p.order.Field.field, DefaultProjectContributorOrder.Field.field,
	) {
		query = query.Where(predicate)
	}
	return query
}

func (p *projectcontributorPager) applyOrder(query *ProjectContributorQuery, reverse bool) *ProjectContributorQuery {
	direction := p.order.Direction
	if reverse {
		direction = direction.reverse()
	}
	query = query.Order(direction.orderFunc(p.order.Field.field))
	if p.order.Field != DefaultProjectContributorOrder.Field {
		query = query.Order(direction.orderFunc(DefaultProjectContributorOrder.Field.field))
	}
	return query
}

func (p *projectcontributorPager) orderExpr(reverse bool) sql.Querier {
	direction := p.order.Direction
	if reverse {
		direction = direction.reverse()
	}
	return sql.ExprFunc(func(b *sql.Builder) {
		b.Ident(p.order.Field.field).Pad().WriteString(string(direction))
		if p.order.Field != DefaultProjectContributorOrder.Field {
			b.Comma().Ident(DefaultProjectContributorOrder.Field.field).Pad().WriteString(string(direction))
		}
	})
}

// Paginate executes the query and returns a relay based cursor connection to ProjectContributor.
func (pc *ProjectContributorQuery) Paginate(
	ctx context.Context, after *Cursor, first *int,
	before *Cursor, last *int, opts ...ProjectContributorPaginateOption,
) (*ProjectContributorConnection, error) {
	if err := validateFirstLast(first, last); err != nil {
		return nil, err
	}
	pager, err := newProjectContributorPager(opts)
	if err != nil {
		return nil, err
	}
	if pc, err = pager.applyFilter(pc); err != nil {
		return nil, err
	}
	conn := &ProjectContributorConnection{Edges: []*ProjectContributorEdge{}}
	ignoredEdges := !hasCollectedField(ctx, edgesField)
	if hasCollectedField(ctx, totalCountField) || hasCollectedField(ctx, pageInfoField) {
		hasPagination := after != nil || first != nil || before != nil || last != nil
		if hasPagination || ignoredEdges {
			if conn.TotalCount, err = pc.Count(ctx); err != nil {
				return nil, err
			}
			conn.PageInfo.HasNextPage = first != nil && conn.TotalCount > 0
			conn.PageInfo.HasPreviousPage = last != nil && conn.TotalCount > 0
		}
	}
	if ignoredEdges || (first != nil && *first == 0) || (last != nil && *last == 0) {
		return conn, nil
	}

	pc = pager.applyCursors(pc, after, before)
	pc = pager.applyOrder(pc, last != nil)
	if limit := paginateLimit(first, last); limit != 0 {
		pc.Limit(limit)
	}
	if field := collectedField(ctx, edgesField, nodeField); field != nil {
		if err := pc.collectField(ctx, graphql.GetOperationContext(ctx), *field, []string{edgesField, nodeField}); err != nil {
			return nil, err
		}
	}

	nodes, err := pc.All(ctx)
	if err != nil {
		return nil, err
	}
	conn.build(nodes, pager, after, first, before, last)
	return conn, nil
}

var (
	// ProjectContributorOrderFieldRole orders ProjectContributor by role.
	ProjectContributorOrderFieldRole = &ProjectContributorOrderField{
		field: projectcontributor.FieldRole,
		toCursor: func(pc *ProjectContributor) Cursor {
			return Cursor{
				ID:    pc.ID,
				Value: pc.Role,
			}
		},
	}
)

// String implement fmt.Stringer interface.
func (f ProjectContributorOrderField) String() string {
	var str string
	switch f.field {
	case projectcontributor.FieldRole:
		str = "ROLE"
	}
	return str
}

// MarshalGQL implements graphql.Marshaler interface.
func (f ProjectContributorOrderField) MarshalGQL(w io.Writer) {
	io.WriteString(w, strconv.Quote(f.String()))
}

// UnmarshalGQL implements graphql.Unmarshaler interface.
func (f *ProjectContributorOrderField) UnmarshalGQL(v interface{}) error {
	str, ok := v.(string)
	if !ok {
		return fmt.Errorf("ProjectContributorOrderField %T must be a string", v)
	}
	switch str {
	case "ROLE":
		*f = *ProjectContributorOrderFieldRole
	default:
		return fmt.Errorf("%s is not a valid ProjectContributorOrderField", str)
	}
	return nil
}

// ProjectContributorOrderField defines the ordering field of ProjectContributor.
type ProjectContributorOrderField struct {
	field    string
	toCursor func(*ProjectContributor) Cursor
}

// ProjectContributorOrder defines the ordering of ProjectContributor.
type ProjectContributorOrder struct {
	Direction OrderDirection                `json:"direction"`
	Field     *ProjectContributorOrderField `json:"field"`
}

// DefaultProjectContributorOrder is the default ordering of ProjectContributor.
var DefaultProjectContributorOrder = &ProjectContributorOrder{
	Direction: OrderDirectionAsc,
	Field: &ProjectContributorOrderField{
		field: projectcontributor.FieldID,
		toCursor: func(pc *ProjectContributor) Cursor {
			return Cursor{ID: pc.ID}
		},
	},
}

// ToEdge converts ProjectContributor into ProjectContributorEdge.
func (pc *ProjectContributor) ToEdge(order *ProjectContributorOrder) *ProjectContributorEdge {
	if order == nil {
		order = DefaultProjectContributorOrder
	}
	return &ProjectContributorEdge{
		Node:   pc,
		Cursor: order.Field.toCursor(pc),
	}
}

// ProjectTechnologyEdge is the edge representation of ProjectTechnology.
type ProjectTechnologyEdge struct {
	Node   *ProjectTechnology `json:"node"`
	Cursor Cursor             `json:"cursor"`
}

// ProjectTechnologyConnection is the connection containing edges to ProjectTechnology.
type ProjectTechnologyConnection struct {
	Edges      []*ProjectTechnologyEdge `json:"edges"`
	PageInfo   PageInfo                 `json:"pageInfo"`
	TotalCount int                      `json:"totalCount"`
}

func (c *ProjectTechnologyConnection) build(nodes []*ProjectTechnology, pager *projecttechnologyPager, after *Cursor, first *int, before *Cursor, last *int) {
	c.PageInfo.HasNextPage = before != nil
	c.PageInfo.HasPreviousPage = after != nil
	if first != nil && *first+1 == len(nodes) {
		c.PageInfo.HasNextPage = true
		nodes = nodes[:len(nodes)-1]
	} else if last != nil && *last+1 == len(nodes) {
		c.PageInfo.HasPreviousPage = true
		nodes = nodes[:len(nodes)-1]
	}
	var nodeAt func(int) *ProjectTechnology
	if last != nil {
		n := len(nodes) - 1
		nodeAt = func(i int) *ProjectTechnology {
			return nodes[n-i]
		}
	} else {
		nodeAt = func(i int) *ProjectTechnology {
			return nodes[i]
		}
	}
	c.Edges = make([]*ProjectTechnologyEdge, len(nodes))
	for i := range nodes {
		node := nodeAt(i)
		c.Edges[i] = &ProjectTechnologyEdge{
			Node:   node,
			Cursor: pager.toCursor(node),
		}
	}
	if l := len(c.Edges); l > 0 {
		c.PageInfo.StartCursor = &c.Edges[0].Cursor
		c.PageInfo.EndCursor = &c.Edges[l-1].Cursor
	}
	if c.TotalCount == 0 {
		c.TotalCount = len(nodes)
	}
}

// ProjectTechnologyPaginateOption enables pagination customization.
type ProjectTechnologyPaginateOption func(*projecttechnologyPager) error

// WithProjectTechnologyOrder configures pagination ordering.
func WithProjectTechnologyOrder(order *ProjectTechnologyOrder) ProjectTechnologyPaginateOption {
	if order == nil {
		order = DefaultProjectTechnologyOrder
	}
	o := *order
	return func(pager *projecttechnologyPager) error {
		if err := o.Direction.Validate(); err != nil {
			return err
		}
		if o.Field == nil {
			o.Field = DefaultProjectTechnologyOrder.Field
		}
		pager.order = &o
		return nil
	}
}

// WithProjectTechnologyFilter configures pagination filter.
func WithProjectTechnologyFilter(filter func(*ProjectTechnologyQuery) (*ProjectTechnologyQuery, error)) ProjectTechnologyPaginateOption {
	return func(pager *projecttechnologyPager) error {
		if filter == nil {
			return errors.New("ProjectTechnologyQuery filter cannot be nil")
		}
		pager.filter = filter
		return nil
	}
}

type projecttechnologyPager struct {
	order  *ProjectTechnologyOrder
	filter func(*ProjectTechnologyQuery) (*ProjectTechnologyQuery, error)
}

func newProjectTechnologyPager(opts []ProjectTechnologyPaginateOption) (*projecttechnologyPager, error) {
	pager := &projecttechnologyPager{}
	for _, opt := range opts {
		if err := opt(pager); err != nil {
			return nil, err
		}
	}
	if pager.order == nil {
		pager.order = DefaultProjectTechnologyOrder
	}
	return pager, nil
}

func (p *projecttechnologyPager) applyFilter(query *ProjectTechnologyQuery) (*ProjectTechnologyQuery, error) {
	if p.filter != nil {
		return p.filter(query)
	}
	return query, nil
}

func (p *projecttechnologyPager) toCursor(pt *ProjectTechnology) Cursor {
	return p.order.Field.toCursor(pt)
}

func (p *projecttechnologyPager) applyCursors(query *ProjectTechnologyQuery, after, before *Cursor) *ProjectTechnologyQuery {
	for _, predicate := range cursorsToPredicates(
		p.order.Direction, after, before,
		p.order.Field.field, DefaultProjectTechnologyOrder.Field.field,
	) {
		query = query.Where(predicate)
	}
	return query
}

func (p *projecttechnologyPager) applyOrder(query *ProjectTechnologyQuery, reverse bool) *ProjectTechnologyQuery {
	direction := p.order.Direction
	if reverse {
		direction = direction.reverse()
	}
	query = query.Order(direction.orderFunc(p.order.Field.field))
	if p.order.Field != DefaultProjectTechnologyOrder.Field {
		query = query.Order(direction.orderFunc(DefaultProjectTechnologyOrder.Field.field))
	}
	return query
}

func (p *projecttechnologyPager) orderExpr(reverse bool) sql.Querier {
	direction := p.order.Direction
	if reverse {
		direction = direction.reverse()
	}
	return sql.ExprFunc(func(b *sql.Builder) {
		b.Ident(p.order.Field.field).Pad().WriteString(string(direction))
		if p.order.Field != DefaultProjectTechnologyOrder.Field {
			b.Comma().Ident(DefaultProjectTechnologyOrder.Field.field).Pad().WriteString(string(direction))
		}
	})
}

// Paginate executes the query and returns a relay based cursor connection to ProjectTechnology.
func (pt *ProjectTechnologyQuery) Paginate(
	ctx context.Context, after *Cursor, first *int,
	before *Cursor, last *int, opts ...ProjectTechnologyPaginateOption,
) (*ProjectTechnologyConnection, error) {
	if err := validateFirstLast(first, last); err != nil {
		return nil, err
	}
	pager, err := newProjectTechnologyPager(opts)
	if err != nil {
		return nil, err
	}
	if pt, err = pager.applyFilter(pt); err != nil {
		return nil, err
	}
	conn := &ProjectTechnologyConnection{Edges: []*ProjectTechnologyEdge{}}
	ignoredEdges := !hasCollectedField(ctx, edgesField)
	if hasCollectedField(ctx, totalCountField) || hasCollectedField(ctx, pageInfoField) {
		hasPagination := after != nil || first != nil || before != nil || last != nil
		if hasPagination || ignoredEdges {
			if conn.TotalCount, err = pt.Count(ctx); err != nil {
				return nil, err
			}
			conn.PageInfo.HasNextPage = first != nil && conn.TotalCount > 0
			conn.PageInfo.HasPreviousPage = last != nil && conn.TotalCount > 0
		}
	}
	if ignoredEdges || (first != nil && *first == 0) || (last != nil && *last == 0) {
		return conn, nil
	}

	pt = pager.applyCursors(pt, after, before)
	pt = pager.applyOrder(pt, last != nil)
	if limit := paginateLimit(first, last); limit != 0 {
		pt.Limit(limit)
	}
	if field := collectedField(ctx, edgesField, nodeField); field != nil {
		if err := pt.collectField(ctx, graphql.GetOperationContext(ctx), *field, []string{edgesField, nodeField}); err != nil {
			return nil, err
		}
	}

	nodes, err := pt.All(ctx)
	if err != nil {
		return nil, err
	}
	conn.build(nodes, pager, after, first, before, last)
	return conn, nil
}

var (
	// ProjectTechnologyOrderFieldType orders ProjectTechnology by type.
	ProjectTechnologyOrderFieldType = &ProjectTechnologyOrderField{
		field: projecttechnology.FieldType,
		toCursor: func(pt *ProjectTechnology) Cursor {
			return Cursor{
				ID:    pt.ID,
				Value: pt.Type,
			}
		},
	}
)

// String implement fmt.Stringer interface.
func (f ProjectTechnologyOrderField) String() string {
	var str string
	switch f.field {
	case projecttechnology.FieldType:
		str = "TYPE"
	}
	return str
}

// MarshalGQL implements graphql.Marshaler interface.
func (f ProjectTechnologyOrderField) MarshalGQL(w io.Writer) {
	io.WriteString(w, strconv.Quote(f.String()))
}

// UnmarshalGQL implements graphql.Unmarshaler interface.
func (f *ProjectTechnologyOrderField) UnmarshalGQL(v interface{}) error {
	str, ok := v.(string)
	if !ok {
		return fmt.Errorf("ProjectTechnologyOrderField %T must be a string", v)
	}
	switch str {
	case "TYPE":
		*f = *ProjectTechnologyOrderFieldType
	default:
		return fmt.Errorf("%s is not a valid ProjectTechnologyOrderField", str)
	}
	return nil
}

// ProjectTechnologyOrderField defines the ordering field of ProjectTechnology.
type ProjectTechnologyOrderField struct {
	field    string
	toCursor func(*ProjectTechnology) Cursor
}

// ProjectTechnologyOrder defines the ordering of ProjectTechnology.
type ProjectTechnologyOrder struct {
	Direction OrderDirection               `json:"direction"`
	Field     *ProjectTechnologyOrderField `json:"field"`
}

// DefaultProjectTechnologyOrder is the default ordering of ProjectTechnology.
var DefaultProjectTechnologyOrder = &ProjectTechnologyOrder{
	Direction: OrderDirectionAsc,
	Field: &ProjectTechnologyOrderField{
		field: projecttechnology.FieldID,
		toCursor: func(pt *ProjectTechnology) Cursor {
			return Cursor{ID: pt.ID}
		},
	},
}

// ToEdge converts ProjectTechnology into ProjectTechnologyEdge.
func (pt *ProjectTechnology) ToEdge(order *ProjectTechnologyOrder) *ProjectTechnologyEdge {
	if order == nil {
		order = DefaultProjectTechnologyOrder
	}
	return &ProjectTechnologyEdge{
		Node:   pt,
		Cursor: order.Field.toCursor(pt),
	}
}

// RepositoryEdge is the edge representation of Repository.
type RepositoryEdge struct {
	Node   *Repository `json:"node"`
	Cursor Cursor      `json:"cursor"`
}

// RepositoryConnection is the connection containing edges to Repository.
type RepositoryConnection struct {
	Edges      []*RepositoryEdge `json:"edges"`
	PageInfo   PageInfo          `json:"pageInfo"`
	TotalCount int               `json:"totalCount"`
}

func (c *RepositoryConnection) build(nodes []*Repository, pager *repositoryPager, after *Cursor, first *int, before *Cursor, last *int) {
	c.PageInfo.HasNextPage = before != nil
	c.PageInfo.HasPreviousPage = after != nil
	if first != nil && *first+1 == len(nodes) {
		c.PageInfo.HasNextPage = true
		nodes = nodes[:len(nodes)-1]
	} else if last != nil && *last+1 == len(nodes) {
		c.PageInfo.HasPreviousPage = true
		nodes = nodes[:len(nodes)-1]
	}
	var nodeAt func(int) *Repository
	if last != nil {
		n := len(nodes) - 1
		nodeAt = func(i int) *Repository {
			return nodes[n-i]
		}
	} else {
		nodeAt = func(i int) *Repository {
			return nodes[i]
		}
	}
	c.Edges = make([]*RepositoryEdge, len(nodes))
	for i := range nodes {
		node := nodeAt(i)
		c.Edges[i] = &RepositoryEdge{
			Node:   node,
			Cursor: pager.toCursor(node),
		}
	}
	if l := len(c.Edges); l > 0 {
		c.PageInfo.StartCursor = &c.Edges[0].Cursor
		c.PageInfo.EndCursor = &c.Edges[l-1].Cursor
	}
	if c.TotalCount == 0 {
		c.TotalCount = len(nodes)
	}
}

// RepositoryPaginateOption enables pagination customization.
type RepositoryPaginateOption func(*repositoryPager) error

// WithRepositoryOrder configures pagination ordering.
func WithRepositoryOrder(order *RepositoryOrder) RepositoryPaginateOption {
	if order == nil {
		order = DefaultRepositoryOrder
	}
	o := *order
	return func(pager *repositoryPager) error {
		if err := o.Direction.Validate(); err != nil {
			return err
		}
		if o.Field == nil {
			o.Field = DefaultRepositoryOrder.Field
		}
		pager.order = &o
		return nil
	}
}

// WithRepositoryFilter configures pagination filter.
func WithRepositoryFilter(filter func(*RepositoryQuery) (*RepositoryQuery, error)) RepositoryPaginateOption {
	return func(pager *repositoryPager) error {
		if filter == nil {
			return errors.New("RepositoryQuery filter cannot be nil")
		}
		pager.filter = filter
		return nil
	}
}

type repositoryPager struct {
	order  *RepositoryOrder
	filter func(*RepositoryQuery) (*RepositoryQuery, error)
}

func newRepositoryPager(opts []RepositoryPaginateOption) (*repositoryPager, error) {
	pager := &repositoryPager{}
	for _, opt := range opts {
		if err := opt(pager); err != nil {
			return nil, err
		}
	}
	if pager.order == nil {
		pager.order = DefaultRepositoryOrder
	}
	return pager, nil
}

func (p *repositoryPager) applyFilter(query *RepositoryQuery) (*RepositoryQuery, error) {
	if p.filter != nil {
		return p.filter(query)
	}
	return query, nil
}

func (p *repositoryPager) toCursor(r *Repository) Cursor {
	return p.order.Field.toCursor(r)
}

func (p *repositoryPager) applyCursors(query *RepositoryQuery, after, before *Cursor) *RepositoryQuery {
	for _, predicate := range cursorsToPredicates(
		p.order.Direction, after, before,
		p.order.Field.field, DefaultRepositoryOrder.Field.field,
	) {
		query = query.Where(predicate)
	}
	return query
}

func (p *repositoryPager) applyOrder(query *RepositoryQuery, reverse bool) *RepositoryQuery {
	direction := p.order.Direction
	if reverse {
		direction = direction.reverse()
	}
	query = query.Order(direction.orderFunc(p.order.Field.field))
	if p.order.Field != DefaultRepositoryOrder.Field {
		query = query.Order(direction.orderFunc(DefaultRepositoryOrder.Field.field))
	}
	return query
}

func (p *repositoryPager) orderExpr(reverse bool) sql.Querier {
	direction := p.order.Direction
	if reverse {
		direction = direction.reverse()
	}
	return sql.ExprFunc(func(b *sql.Builder) {
		b.Ident(p.order.Field.field).Pad().WriteString(string(direction))
		if p.order.Field != DefaultRepositoryOrder.Field {
			b.Comma().Ident(DefaultRepositoryOrder.Field.field).Pad().WriteString(string(direction))
		}
	})
}

// Paginate executes the query and returns a relay based cursor connection to Repository.
func (r *RepositoryQuery) Paginate(
	ctx context.Context, after *Cursor, first *int,
	before *Cursor, last *int, opts ...RepositoryPaginateOption,
) (*RepositoryConnection, error) {
	if err := validateFirstLast(first, last); err != nil {
		return nil, err
	}
	pager, err := newRepositoryPager(opts)
	if err != nil {
		return nil, err
	}
	if r, err = pager.applyFilter(r); err != nil {
		return nil, err
	}
	conn := &RepositoryConnection{Edges: []*RepositoryEdge{}}
	ignoredEdges := !hasCollectedField(ctx, edgesField)
	if hasCollectedField(ctx, totalCountField) || hasCollectedField(ctx, pageInfoField) {
		hasPagination := after != nil || first != nil || before != nil || last != nil
		if hasPagination || ignoredEdges {
			if conn.TotalCount, err = r.Count(ctx); err != nil {
				return nil, err
			}
			conn.PageInfo.HasNextPage = first != nil && conn.TotalCount > 0
			conn.PageInfo.HasPreviousPage = last != nil && conn.TotalCount > 0
		}
	}
	if ignoredEdges || (first != nil && *first == 0) || (last != nil && *last == 0) {
		return conn, nil
	}

	r = pager.applyCursors(r, after, before)
	r = pager.applyOrder(r, last != nil)
	if limit := paginateLimit(first, last); limit != 0 {
		r.Limit(limit)
	}
	if field := collectedField(ctx, edgesField, nodeField); field != nil {
		if err := r.collectField(ctx, graphql.GetOperationContext(ctx), *field, []string{edgesField, nodeField}); err != nil {
			return nil, err
		}
	}

	nodes, err := r.All(ctx)
	if err != nil {
		return nil, err
	}
	conn.build(nodes, pager, after, first, before, last)
	return conn, nil
}

var (
	// RepositoryOrderFieldName orders Repository by name.
	RepositoryOrderFieldName = &RepositoryOrderField{
		field: repository.FieldName,
		toCursor: func(r *Repository) Cursor {
			return Cursor{
				ID:    r.ID,
				Value: r.Name,
			}
		},
	}
	// RepositoryOrderFieldDescription orders Repository by description.
	RepositoryOrderFieldDescription = &RepositoryOrderField{
		field: repository.FieldDescription,
		toCursor: func(r *Repository) Cursor {
			return Cursor{
				ID:    r.ID,
				Value: r.Description,
			}
		},
	}
)

// String implement fmt.Stringer interface.
func (f RepositoryOrderField) String() string {
	var str string
	switch f.field {
	case repository.FieldName:
		str = "NAME"
	case repository.FieldDescription:
		str = "DESCRIPTION"
	}
	return str
}

// MarshalGQL implements graphql.Marshaler interface.
func (f RepositoryOrderField) MarshalGQL(w io.Writer) {
	io.WriteString(w, strconv.Quote(f.String()))
}

// UnmarshalGQL implements graphql.Unmarshaler interface.
func (f *RepositoryOrderField) UnmarshalGQL(v interface{}) error {
	str, ok := v.(string)
	if !ok {
		return fmt.Errorf("RepositoryOrderField %T must be a string", v)
	}
	switch str {
	case "NAME":
		*f = *RepositoryOrderFieldName
	case "DESCRIPTION":
		*f = *RepositoryOrderFieldDescription
	default:
		return fmt.Errorf("%s is not a valid RepositoryOrderField", str)
	}
	return nil
}

// RepositoryOrderField defines the ordering field of Repository.
type RepositoryOrderField struct {
	field    string
	toCursor func(*Repository) Cursor
}

// RepositoryOrder defines the ordering of Repository.
type RepositoryOrder struct {
	Direction OrderDirection        `json:"direction"`
	Field     *RepositoryOrderField `json:"field"`
}

// DefaultRepositoryOrder is the default ordering of Repository.
var DefaultRepositoryOrder = &RepositoryOrder{
	Direction: OrderDirectionAsc,
	Field: &RepositoryOrderField{
		field: repository.FieldID,
		toCursor: func(r *Repository) Cursor {
			return Cursor{ID: r.ID}
		},
	},
}

// ToEdge converts Repository into RepositoryEdge.
func (r *Repository) ToEdge(order *RepositoryOrder) *RepositoryEdge {
	if order == nil {
		order = DefaultRepositoryOrder
	}
	return &RepositoryEdge{
		Node:   r,
		Cursor: order.Field.toCursor(r),
	}
}

// RepositoryTechnologyEdge is the edge representation of RepositoryTechnology.
type RepositoryTechnologyEdge struct {
	Node   *RepositoryTechnology `json:"node"`
	Cursor Cursor                `json:"cursor"`
}

// RepositoryTechnologyConnection is the connection containing edges to RepositoryTechnology.
type RepositoryTechnologyConnection struct {
	Edges      []*RepositoryTechnologyEdge `json:"edges"`
	PageInfo   PageInfo                    `json:"pageInfo"`
	TotalCount int                         `json:"totalCount"`
}

func (c *RepositoryTechnologyConnection) build(nodes []*RepositoryTechnology, pager *repositorytechnologyPager, after *Cursor, first *int, before *Cursor, last *int) {
	c.PageInfo.HasNextPage = before != nil
	c.PageInfo.HasPreviousPage = after != nil
	if first != nil && *first+1 == len(nodes) {
		c.PageInfo.HasNextPage = true
		nodes = nodes[:len(nodes)-1]
	} else if last != nil && *last+1 == len(nodes) {
		c.PageInfo.HasPreviousPage = true
		nodes = nodes[:len(nodes)-1]
	}
	var nodeAt func(int) *RepositoryTechnology
	if last != nil {
		n := len(nodes) - 1
		nodeAt = func(i int) *RepositoryTechnology {
			return nodes[n-i]
		}
	} else {
		nodeAt = func(i int) *RepositoryTechnology {
			return nodes[i]
		}
	}
	c.Edges = make([]*RepositoryTechnologyEdge, len(nodes))
	for i := range nodes {
		node := nodeAt(i)
		c.Edges[i] = &RepositoryTechnologyEdge{
			Node:   node,
			Cursor: pager.toCursor(node),
		}
	}
	if l := len(c.Edges); l > 0 {
		c.PageInfo.StartCursor = &c.Edges[0].Cursor
		c.PageInfo.EndCursor = &c.Edges[l-1].Cursor
	}
	if c.TotalCount == 0 {
		c.TotalCount = len(nodes)
	}
}

// RepositoryTechnologyPaginateOption enables pagination customization.
type RepositoryTechnologyPaginateOption func(*repositorytechnologyPager) error

// WithRepositoryTechnologyOrder configures pagination ordering.
func WithRepositoryTechnologyOrder(order *RepositoryTechnologyOrder) RepositoryTechnologyPaginateOption {
	if order == nil {
		order = DefaultRepositoryTechnologyOrder
	}
	o := *order
	return func(pager *repositorytechnologyPager) error {
		if err := o.Direction.Validate(); err != nil {
			return err
		}
		if o.Field == nil {
			o.Field = DefaultRepositoryTechnologyOrder.Field
		}
		pager.order = &o
		return nil
	}
}

// WithRepositoryTechnologyFilter configures pagination filter.
func WithRepositoryTechnologyFilter(filter func(*RepositoryTechnologyQuery) (*RepositoryTechnologyQuery, error)) RepositoryTechnologyPaginateOption {
	return func(pager *repositorytechnologyPager) error {
		if filter == nil {
			return errors.New("RepositoryTechnologyQuery filter cannot be nil")
		}
		pager.filter = filter
		return nil
	}
}

type repositorytechnologyPager struct {
	order  *RepositoryTechnologyOrder
	filter func(*RepositoryTechnologyQuery) (*RepositoryTechnologyQuery, error)
}

func newRepositoryTechnologyPager(opts []RepositoryTechnologyPaginateOption) (*repositorytechnologyPager, error) {
	pager := &repositorytechnologyPager{}
	for _, opt := range opts {
		if err := opt(pager); err != nil {
			return nil, err
		}
	}
	if pager.order == nil {
		pager.order = DefaultRepositoryTechnologyOrder
	}
	return pager, nil
}

func (p *repositorytechnologyPager) applyFilter(query *RepositoryTechnologyQuery) (*RepositoryTechnologyQuery, error) {
	if p.filter != nil {
		return p.filter(query)
	}
	return query, nil
}

func (p *repositorytechnologyPager) toCursor(rt *RepositoryTechnology) Cursor {
	return p.order.Field.toCursor(rt)
}

func (p *repositorytechnologyPager) applyCursors(query *RepositoryTechnologyQuery, after, before *Cursor) *RepositoryTechnologyQuery {
	for _, predicate := range cursorsToPredicates(
		p.order.Direction, after, before,
		p.order.Field.field, DefaultRepositoryTechnologyOrder.Field.field,
	) {
		query = query.Where(predicate)
	}
	return query
}

func (p *repositorytechnologyPager) applyOrder(query *RepositoryTechnologyQuery, reverse bool) *RepositoryTechnologyQuery {
	direction := p.order.Direction
	if reverse {
		direction = direction.reverse()
	}
	query = query.Order(direction.orderFunc(p.order.Field.field))
	if p.order.Field != DefaultRepositoryTechnologyOrder.Field {
		query = query.Order(direction.orderFunc(DefaultRepositoryTechnologyOrder.Field.field))
	}
	return query
}

func (p *repositorytechnologyPager) orderExpr(reverse bool) sql.Querier {
	direction := p.order.Direction
	if reverse {
		direction = direction.reverse()
	}
	return sql.ExprFunc(func(b *sql.Builder) {
		b.Ident(p.order.Field.field).Pad().WriteString(string(direction))
		if p.order.Field != DefaultRepositoryTechnologyOrder.Field {
			b.Comma().Ident(DefaultRepositoryTechnologyOrder.Field.field).Pad().WriteString(string(direction))
		}
	})
}

// Paginate executes the query and returns a relay based cursor connection to RepositoryTechnology.
func (rt *RepositoryTechnologyQuery) Paginate(
	ctx context.Context, after *Cursor, first *int,
	before *Cursor, last *int, opts ...RepositoryTechnologyPaginateOption,
) (*RepositoryTechnologyConnection, error) {
	if err := validateFirstLast(first, last); err != nil {
		return nil, err
	}
	pager, err := newRepositoryTechnologyPager(opts)
	if err != nil {
		return nil, err
	}
	if rt, err = pager.applyFilter(rt); err != nil {
		return nil, err
	}
	conn := &RepositoryTechnologyConnection{Edges: []*RepositoryTechnologyEdge{}}
	ignoredEdges := !hasCollectedField(ctx, edgesField)
	if hasCollectedField(ctx, totalCountField) || hasCollectedField(ctx, pageInfoField) {
		hasPagination := after != nil || first != nil || before != nil || last != nil
		if hasPagination || ignoredEdges {
			if conn.TotalCount, err = rt.Count(ctx); err != nil {
				return nil, err
			}
			conn.PageInfo.HasNextPage = first != nil && conn.TotalCount > 0
			conn.PageInfo.HasPreviousPage = last != nil && conn.TotalCount > 0
		}
	}
	if ignoredEdges || (first != nil && *first == 0) || (last != nil && *last == 0) {
		return conn, nil
	}

	rt = pager.applyCursors(rt, after, before)
	rt = pager.applyOrder(rt, last != nil)
	if limit := paginateLimit(first, last); limit != 0 {
		rt.Limit(limit)
	}
	if field := collectedField(ctx, edgesField, nodeField); field != nil {
		if err := rt.collectField(ctx, graphql.GetOperationContext(ctx), *field, []string{edgesField, nodeField}); err != nil {
			return nil, err
		}
	}

	nodes, err := rt.All(ctx)
	if err != nil {
		return nil, err
	}
	conn.build(nodes, pager, after, first, before, last)
	return conn, nil
}

var (
	// RepositoryTechnologyOrderFieldType orders RepositoryTechnology by type.
	RepositoryTechnologyOrderFieldType = &RepositoryTechnologyOrderField{
		field: repositorytechnology.FieldType,
		toCursor: func(rt *RepositoryTechnology) Cursor {
			return Cursor{
				ID:    rt.ID,
				Value: rt.Type,
			}
		},
	}
)

// String implement fmt.Stringer interface.
func (f RepositoryTechnologyOrderField) String() string {
	var str string
	switch f.field {
	case repositorytechnology.FieldType:
		str = "TYPE"
	}
	return str
}

// MarshalGQL implements graphql.Marshaler interface.
func (f RepositoryTechnologyOrderField) MarshalGQL(w io.Writer) {
	io.WriteString(w, strconv.Quote(f.String()))
}

// UnmarshalGQL implements graphql.Unmarshaler interface.
func (f *RepositoryTechnologyOrderField) UnmarshalGQL(v interface{}) error {
	str, ok := v.(string)
	if !ok {
		return fmt.Errorf("RepositoryTechnologyOrderField %T must be a string", v)
	}
	switch str {
	case "TYPE":
		*f = *RepositoryTechnologyOrderFieldType
	default:
		return fmt.Errorf("%s is not a valid RepositoryTechnologyOrderField", str)
	}
	return nil
}

// RepositoryTechnologyOrderField defines the ordering field of RepositoryTechnology.
type RepositoryTechnologyOrderField struct {
	field    string
	toCursor func(*RepositoryTechnology) Cursor
}

// RepositoryTechnologyOrder defines the ordering of RepositoryTechnology.
type RepositoryTechnologyOrder struct {
	Direction OrderDirection                  `json:"direction"`
	Field     *RepositoryTechnologyOrderField `json:"field"`
}

// DefaultRepositoryTechnologyOrder is the default ordering of RepositoryTechnology.
var DefaultRepositoryTechnologyOrder = &RepositoryTechnologyOrder{
	Direction: OrderDirectionAsc,
	Field: &RepositoryTechnologyOrderField{
		field: repositorytechnology.FieldID,
		toCursor: func(rt *RepositoryTechnology) Cursor {
			return Cursor{ID: rt.ID}
		},
	},
}

// ToEdge converts RepositoryTechnology into RepositoryTechnologyEdge.
func (rt *RepositoryTechnology) ToEdge(order *RepositoryTechnologyOrder) *RepositoryTechnologyEdge {
	if order == nil {
		order = DefaultRepositoryTechnologyOrder
	}
	return &RepositoryTechnologyEdge{
		Node:   rt,
		Cursor: order.Field.toCursor(rt),
	}
}

// SiteEdge is the edge representation of Site.
type SiteEdge struct {
	Node   *Site  `json:"node"`
	Cursor Cursor `json:"cursor"`
}

// SiteConnection is the connection containing edges to Site.
type SiteConnection struct {
	Edges      []*SiteEdge `json:"edges"`
	PageInfo   PageInfo    `json:"pageInfo"`
	TotalCount int         `json:"totalCount"`
}

func (c *SiteConnection) build(nodes []*Site, pager *sitePager, after *Cursor, first *int, before *Cursor, last *int) {
	c.PageInfo.HasNextPage = before != nil
	c.PageInfo.HasPreviousPage = after != nil
	if first != nil && *first+1 == len(nodes) {
		c.PageInfo.HasNextPage = true
		nodes = nodes[:len(nodes)-1]
	} else if last != nil && *last+1 == len(nodes) {
		c.PageInfo.HasPreviousPage = true
		nodes = nodes[:len(nodes)-1]
	}
	var nodeAt func(int) *Site
	if last != nil {
		n := len(nodes) - 1
		nodeAt = func(i int) *Site {
			return nodes[n-i]
		}
	} else {
		nodeAt = func(i int) *Site {
			return nodes[i]
		}
	}
	c.Edges = make([]*SiteEdge, len(nodes))
	for i := range nodes {
		node := nodeAt(i)
		c.Edges[i] = &SiteEdge{
			Node:   node,
			Cursor: pager.toCursor(node),
		}
	}
	if l := len(c.Edges); l > 0 {
		c.PageInfo.StartCursor = &c.Edges[0].Cursor
		c.PageInfo.EndCursor = &c.Edges[l-1].Cursor
	}
	if c.TotalCount == 0 {
		c.TotalCount = len(nodes)
	}
}

// SitePaginateOption enables pagination customization.
type SitePaginateOption func(*sitePager) error

// WithSiteOrder configures pagination ordering.
func WithSiteOrder(order *SiteOrder) SitePaginateOption {
	if order == nil {
		order = DefaultSiteOrder
	}
	o := *order
	return func(pager *sitePager) error {
		if err := o.Direction.Validate(); err != nil {
			return err
		}
		if o.Field == nil {
			o.Field = DefaultSiteOrder.Field
		}
		pager.order = &o
		return nil
	}
}

// WithSiteFilter configures pagination filter.
func WithSiteFilter(filter func(*SiteQuery) (*SiteQuery, error)) SitePaginateOption {
	return func(pager *sitePager) error {
		if filter == nil {
			return errors.New("SiteQuery filter cannot be nil")
		}
		pager.filter = filter
		return nil
	}
}

type sitePager struct {
	order  *SiteOrder
	filter func(*SiteQuery) (*SiteQuery, error)
}

func newSitePager(opts []SitePaginateOption) (*sitePager, error) {
	pager := &sitePager{}
	for _, opt := range opts {
		if err := opt(pager); err != nil {
			return nil, err
		}
	}
	if pager.order == nil {
		pager.order = DefaultSiteOrder
	}
	return pager, nil
}

func (p *sitePager) applyFilter(query *SiteQuery) (*SiteQuery, error) {
	if p.filter != nil {
		return p.filter(query)
	}
	return query, nil
}

func (p *sitePager) toCursor(s *Site) Cursor {
	return p.order.Field.toCursor(s)
}

func (p *sitePager) applyCursors(query *SiteQuery, after, before *Cursor) *SiteQuery {
	for _, predicate := range cursorsToPredicates(
		p.order.Direction, after, before,
		p.order.Field.field, DefaultSiteOrder.Field.field,
	) {
		query = query.Where(predicate)
	}
	return query
}

func (p *sitePager) applyOrder(query *SiteQuery, reverse bool) *SiteQuery {
	direction := p.order.Direction
	if reverse {
		direction = direction.reverse()
	}
	query = query.Order(direction.orderFunc(p.order.Field.field))
	if p.order.Field != DefaultSiteOrder.Field {
		query = query.Order(direction.orderFunc(DefaultSiteOrder.Field.field))
	}
	return query
}

func (p *sitePager) orderExpr(reverse bool) sql.Querier {
	direction := p.order.Direction
	if reverse {
		direction = direction.reverse()
	}
	return sql.ExprFunc(func(b *sql.Builder) {
		b.Ident(p.order.Field.field).Pad().WriteString(string(direction))
		if p.order.Field != DefaultSiteOrder.Field {
			b.Comma().Ident(DefaultSiteOrder.Field.field).Pad().WriteString(string(direction))
		}
	})
}

// Paginate executes the query and returns a relay based cursor connection to Site.
func (s *SiteQuery) Paginate(
	ctx context.Context, after *Cursor, first *int,
	before *Cursor, last *int, opts ...SitePaginateOption,
) (*SiteConnection, error) {
	if err := validateFirstLast(first, last); err != nil {
		return nil, err
	}
	pager, err := newSitePager(opts)
	if err != nil {
		return nil, err
	}
	if s, err = pager.applyFilter(s); err != nil {
		return nil, err
	}
	conn := &SiteConnection{Edges: []*SiteEdge{}}
	ignoredEdges := !hasCollectedField(ctx, edgesField)
	if hasCollectedField(ctx, totalCountField) || hasCollectedField(ctx, pageInfoField) {
		hasPagination := after != nil || first != nil || before != nil || last != nil
		if hasPagination || ignoredEdges {
			if conn.TotalCount, err = s.Count(ctx); err != nil {
				return nil, err
			}
			conn.PageInfo.HasNextPage = first != nil && conn.TotalCount > 0
			conn.PageInfo.HasPreviousPage = last != nil && conn.TotalCount > 0
		}
	}
	if ignoredEdges || (first != nil && *first == 0) || (last != nil && *last == 0) {
		return conn, nil
	}

	s = pager.applyCursors(s, after, before)
	s = pager.applyOrder(s, last != nil)
	if limit := paginateLimit(first, last); limit != 0 {
		s.Limit(limit)
	}
	if field := collectedField(ctx, edgesField, nodeField); field != nil {
		if err := s.collectField(ctx, graphql.GetOperationContext(ctx), *field, []string{edgesField, nodeField}); err != nil {
			return nil, err
		}
	}

	nodes, err := s.All(ctx)
	if err != nil {
		return nil, err
	}
	conn.build(nodes, pager, after, first, before, last)
	return conn, nil
}

var (
	// SiteOrderFieldURL orders Site by url.
	SiteOrderFieldURL = &SiteOrderField{
		field: site.FieldURL,
		toCursor: func(s *Site) Cursor {
			return Cursor{
				ID:    s.ID,
				Value: s.URL,
			}
		},
	}
)

// String implement fmt.Stringer interface.
func (f SiteOrderField) String() string {
	var str string
	switch f.field {
	case site.FieldURL:
		str = "URL"
	}
	return str
}

// MarshalGQL implements graphql.Marshaler interface.
func (f SiteOrderField) MarshalGQL(w io.Writer) {
	io.WriteString(w, strconv.Quote(f.String()))
}

// UnmarshalGQL implements graphql.Unmarshaler interface.
func (f *SiteOrderField) UnmarshalGQL(v interface{}) error {
	str, ok := v.(string)
	if !ok {
		return fmt.Errorf("SiteOrderField %T must be a string", v)
	}
	switch str {
	case "URL":
		*f = *SiteOrderFieldURL
	default:
		return fmt.Errorf("%s is not a valid SiteOrderField", str)
	}
	return nil
}

// SiteOrderField defines the ordering field of Site.
type SiteOrderField struct {
	field    string
	toCursor func(*Site) Cursor
}

// SiteOrder defines the ordering of Site.
type SiteOrder struct {
	Direction OrderDirection  `json:"direction"`
	Field     *SiteOrderField `json:"field"`
}

// DefaultSiteOrder is the default ordering of Site.
var DefaultSiteOrder = &SiteOrder{
	Direction: OrderDirectionAsc,
	Field: &SiteOrderField{
		field: site.FieldID,
		toCursor: func(s *Site) Cursor {
			return Cursor{ID: s.ID}
		},
	},
}

// ToEdge converts Site into SiteEdge.
func (s *Site) ToEdge(order *SiteOrder) *SiteEdge {
	if order == nil {
		order = DefaultSiteOrder
	}
	return &SiteEdge{
		Node:   s,
		Cursor: order.Field.toCursor(s),
	}
}

// TechnologyEdge is the edge representation of Technology.
type TechnologyEdge struct {
	Node   *Technology `json:"node"`
	Cursor Cursor      `json:"cursor"`
}

// TechnologyConnection is the connection containing edges to Technology.
type TechnologyConnection struct {
	Edges      []*TechnologyEdge `json:"edges"`
	PageInfo   PageInfo          `json:"pageInfo"`
	TotalCount int               `json:"totalCount"`
}

func (c *TechnologyConnection) build(nodes []*Technology, pager *technologyPager, after *Cursor, first *int, before *Cursor, last *int) {
	c.PageInfo.HasNextPage = before != nil
	c.PageInfo.HasPreviousPage = after != nil
	if first != nil && *first+1 == len(nodes) {
		c.PageInfo.HasNextPage = true
		nodes = nodes[:len(nodes)-1]
	} else if last != nil && *last+1 == len(nodes) {
		c.PageInfo.HasPreviousPage = true
		nodes = nodes[:len(nodes)-1]
	}
	var nodeAt func(int) *Technology
	if last != nil {
		n := len(nodes) - 1
		nodeAt = func(i int) *Technology {
			return nodes[n-i]
		}
	} else {
		nodeAt = func(i int) *Technology {
			return nodes[i]
		}
	}
	c.Edges = make([]*TechnologyEdge, len(nodes))
	for i := range nodes {
		node := nodeAt(i)
		c.Edges[i] = &TechnologyEdge{
			Node:   node,
			Cursor: pager.toCursor(node),
		}
	}
	if l := len(c.Edges); l > 0 {
		c.PageInfo.StartCursor = &c.Edges[0].Cursor
		c.PageInfo.EndCursor = &c.Edges[l-1].Cursor
	}
	if c.TotalCount == 0 {
		c.TotalCount = len(nodes)
	}
}

// TechnologyPaginateOption enables pagination customization.
type TechnologyPaginateOption func(*technologyPager) error

// WithTechnologyOrder configures pagination ordering.
func WithTechnologyOrder(order *TechnologyOrder) TechnologyPaginateOption {
	if order == nil {
		order = DefaultTechnologyOrder
	}
	o := *order
	return func(pager *technologyPager) error {
		if err := o.Direction.Validate(); err != nil {
			return err
		}
		if o.Field == nil {
			o.Field = DefaultTechnologyOrder.Field
		}
		pager.order = &o
		return nil
	}
}

// WithTechnologyFilter configures pagination filter.
func WithTechnologyFilter(filter func(*TechnologyQuery) (*TechnologyQuery, error)) TechnologyPaginateOption {
	return func(pager *technologyPager) error {
		if filter == nil {
			return errors.New("TechnologyQuery filter cannot be nil")
		}
		pager.filter = filter
		return nil
	}
}

type technologyPager struct {
	order  *TechnologyOrder
	filter func(*TechnologyQuery) (*TechnologyQuery, error)
}

func newTechnologyPager(opts []TechnologyPaginateOption) (*technologyPager, error) {
	pager := &technologyPager{}
	for _, opt := range opts {
		if err := opt(pager); err != nil {
			return nil, err
		}
	}
	if pager.order == nil {
		pager.order = DefaultTechnologyOrder
	}
	return pager, nil
}

func (p *technologyPager) applyFilter(query *TechnologyQuery) (*TechnologyQuery, error) {
	if p.filter != nil {
		return p.filter(query)
	}
	return query, nil
}

func (p *technologyPager) toCursor(t *Technology) Cursor {
	return p.order.Field.toCursor(t)
}

func (p *technologyPager) applyCursors(query *TechnologyQuery, after, before *Cursor) *TechnologyQuery {
	for _, predicate := range cursorsToPredicates(
		p.order.Direction, after, before,
		p.order.Field.field, DefaultTechnologyOrder.Field.field,
	) {
		query = query.Where(predicate)
	}
	return query
}

func (p *technologyPager) applyOrder(query *TechnologyQuery, reverse bool) *TechnologyQuery {
	direction := p.order.Direction
	if reverse {
		direction = direction.reverse()
	}
	query = query.Order(direction.orderFunc(p.order.Field.field))
	if p.order.Field != DefaultTechnologyOrder.Field {
		query = query.Order(direction.orderFunc(DefaultTechnologyOrder.Field.field))
	}
	return query
}

func (p *technologyPager) orderExpr(reverse bool) sql.Querier {
	direction := p.order.Direction
	if reverse {
		direction = direction.reverse()
	}
	return sql.ExprFunc(func(b *sql.Builder) {
		b.Ident(p.order.Field.field).Pad().WriteString(string(direction))
		if p.order.Field != DefaultTechnologyOrder.Field {
			b.Comma().Ident(DefaultTechnologyOrder.Field.field).Pad().WriteString(string(direction))
		}
	})
}

// Paginate executes the query and returns a relay based cursor connection to Technology.
func (t *TechnologyQuery) Paginate(
	ctx context.Context, after *Cursor, first *int,
	before *Cursor, last *int, opts ...TechnologyPaginateOption,
) (*TechnologyConnection, error) {
	if err := validateFirstLast(first, last); err != nil {
		return nil, err
	}
	pager, err := newTechnologyPager(opts)
	if err != nil {
		return nil, err
	}
	if t, err = pager.applyFilter(t); err != nil {
		return nil, err
	}
	conn := &TechnologyConnection{Edges: []*TechnologyEdge{}}
	ignoredEdges := !hasCollectedField(ctx, edgesField)
	if hasCollectedField(ctx, totalCountField) || hasCollectedField(ctx, pageInfoField) {
		hasPagination := after != nil || first != nil || before != nil || last != nil
		if hasPagination || ignoredEdges {
			if conn.TotalCount, err = t.Count(ctx); err != nil {
				return nil, err
			}
			conn.PageInfo.HasNextPage = first != nil && conn.TotalCount > 0
			conn.PageInfo.HasPreviousPage = last != nil && conn.TotalCount > 0
		}
	}
	if ignoredEdges || (first != nil && *first == 0) || (last != nil && *last == 0) {
		return conn, nil
	}

	t = pager.applyCursors(t, after, before)
	t = pager.applyOrder(t, last != nil)
	if limit := paginateLimit(first, last); limit != 0 {
		t.Limit(limit)
	}
	if field := collectedField(ctx, edgesField, nodeField); field != nil {
		if err := t.collectField(ctx, graphql.GetOperationContext(ctx), *field, []string{edgesField, nodeField}); err != nil {
			return nil, err
		}
	}

	nodes, err := t.All(ctx)
	if err != nil {
		return nil, err
	}
	conn.build(nodes, pager, after, first, before, last)
	return conn, nil
}

var (
	// TechnologyOrderFieldName orders Technology by name.
	TechnologyOrderFieldName = &TechnologyOrderField{
		field: technology.FieldName,
		toCursor: func(t *Technology) Cursor {
			return Cursor{
				ID:    t.ID,
				Value: t.Name,
			}
		},
	}
	// TechnologyOrderFieldDescription orders Technology by description.
	TechnologyOrderFieldDescription = &TechnologyOrderField{
		field: technology.FieldDescription,
		toCursor: func(t *Technology) Cursor {
			return Cursor{
				ID:    t.ID,
				Value: t.Description,
			}
		},
	}
	// TechnologyOrderFieldColour orders Technology by colour.
	TechnologyOrderFieldColour = &TechnologyOrderField{
		field: technology.FieldColour,
		toCursor: func(t *Technology) Cursor {
			return Cursor{
				ID:    t.ID,
				Value: t.Colour,
			}
		},
	}
	// TechnologyOrderFieldType orders Technology by type.
	TechnologyOrderFieldType = &TechnologyOrderField{
		field: technology.FieldType,
		toCursor: func(t *Technology) Cursor {
			return Cursor{
				ID:    t.ID,
				Value: t.Type,
			}
		},
	}
)

// String implement fmt.Stringer interface.
func (f TechnologyOrderField) String() string {
	var str string
	switch f.field {
	case technology.FieldName:
		str = "NAME"
	case technology.FieldDescription:
		str = "DESCRIPTION"
	case technology.FieldColour:
		str = "COLOUR"
	case technology.FieldType:
		str = "TYPE"
	}
	return str
}

// MarshalGQL implements graphql.Marshaler interface.
func (f TechnologyOrderField) MarshalGQL(w io.Writer) {
	io.WriteString(w, strconv.Quote(f.String()))
}

// UnmarshalGQL implements graphql.Unmarshaler interface.
func (f *TechnologyOrderField) UnmarshalGQL(v interface{}) error {
	str, ok := v.(string)
	if !ok {
		return fmt.Errorf("TechnologyOrderField %T must be a string", v)
	}
	switch str {
	case "NAME":
		*f = *TechnologyOrderFieldName
	case "DESCRIPTION":
		*f = *TechnologyOrderFieldDescription
	case "COLOUR":
		*f = *TechnologyOrderFieldColour
	case "TYPE":
		*f = *TechnologyOrderFieldType
	default:
		return fmt.Errorf("%s is not a valid TechnologyOrderField", str)
	}
	return nil
}

// TechnologyOrderField defines the ordering field of Technology.
type TechnologyOrderField struct {
	field    string
	toCursor func(*Technology) Cursor
}

// TechnologyOrder defines the ordering of Technology.
type TechnologyOrder struct {
	Direction OrderDirection        `json:"direction"`
	Field     *TechnologyOrderField `json:"field"`
}

// DefaultTechnologyOrder is the default ordering of Technology.
var DefaultTechnologyOrder = &TechnologyOrder{
	Direction: OrderDirectionAsc,
	Field: &TechnologyOrderField{
		field: technology.FieldID,
		toCursor: func(t *Technology) Cursor {
			return Cursor{ID: t.ID}
		},
	},
}

// ToEdge converts Technology into TechnologyEdge.
func (t *Technology) ToEdge(order *TechnologyOrder) *TechnologyEdge {
	if order == nil {
		order = DefaultTechnologyOrder
	}
	return &TechnologyEdge{
		Node:   t,
		Cursor: order.Field.toCursor(t),
	}
}

// TechnologyAssociationEdge is the edge representation of TechnologyAssociation.
type TechnologyAssociationEdge struct {
	Node   *TechnologyAssociation `json:"node"`
	Cursor Cursor                 `json:"cursor"`
}

// TechnologyAssociationConnection is the connection containing edges to TechnologyAssociation.
type TechnologyAssociationConnection struct {
	Edges      []*TechnologyAssociationEdge `json:"edges"`
	PageInfo   PageInfo                     `json:"pageInfo"`
	TotalCount int                          `json:"totalCount"`
}

func (c *TechnologyAssociationConnection) build(nodes []*TechnologyAssociation, pager *technologyassociationPager, after *Cursor, first *int, before *Cursor, last *int) {
	c.PageInfo.HasNextPage = before != nil
	c.PageInfo.HasPreviousPage = after != nil
	if first != nil && *first+1 == len(nodes) {
		c.PageInfo.HasNextPage = true
		nodes = nodes[:len(nodes)-1]
	} else if last != nil && *last+1 == len(nodes) {
		c.PageInfo.HasPreviousPage = true
		nodes = nodes[:len(nodes)-1]
	}
	var nodeAt func(int) *TechnologyAssociation
	if last != nil {
		n := len(nodes) - 1
		nodeAt = func(i int) *TechnologyAssociation {
			return nodes[n-i]
		}
	} else {
		nodeAt = func(i int) *TechnologyAssociation {
			return nodes[i]
		}
	}
	c.Edges = make([]*TechnologyAssociationEdge, len(nodes))
	for i := range nodes {
		node := nodeAt(i)
		c.Edges[i] = &TechnologyAssociationEdge{
			Node:   node,
			Cursor: pager.toCursor(node),
		}
	}
	if l := len(c.Edges); l > 0 {
		c.PageInfo.StartCursor = &c.Edges[0].Cursor
		c.PageInfo.EndCursor = &c.Edges[l-1].Cursor
	}
	if c.TotalCount == 0 {
		c.TotalCount = len(nodes)
	}
}

// TechnologyAssociationPaginateOption enables pagination customization.
type TechnologyAssociationPaginateOption func(*technologyassociationPager) error

// WithTechnologyAssociationOrder configures pagination ordering.
func WithTechnologyAssociationOrder(order *TechnologyAssociationOrder) TechnologyAssociationPaginateOption {
	if order == nil {
		order = DefaultTechnologyAssociationOrder
	}
	o := *order
	return func(pager *technologyassociationPager) error {
		if err := o.Direction.Validate(); err != nil {
			return err
		}
		if o.Field == nil {
			o.Field = DefaultTechnologyAssociationOrder.Field
		}
		pager.order = &o
		return nil
	}
}

// WithTechnologyAssociationFilter configures pagination filter.
func WithTechnologyAssociationFilter(filter func(*TechnologyAssociationQuery) (*TechnologyAssociationQuery, error)) TechnologyAssociationPaginateOption {
	return func(pager *technologyassociationPager) error {
		if filter == nil {
			return errors.New("TechnologyAssociationQuery filter cannot be nil")
		}
		pager.filter = filter
		return nil
	}
}

type technologyassociationPager struct {
	order  *TechnologyAssociationOrder
	filter func(*TechnologyAssociationQuery) (*TechnologyAssociationQuery, error)
}

func newTechnologyAssociationPager(opts []TechnologyAssociationPaginateOption) (*technologyassociationPager, error) {
	pager := &technologyassociationPager{}
	for _, opt := range opts {
		if err := opt(pager); err != nil {
			return nil, err
		}
	}
	if pager.order == nil {
		pager.order = DefaultTechnologyAssociationOrder
	}
	return pager, nil
}

func (p *technologyassociationPager) applyFilter(query *TechnologyAssociationQuery) (*TechnologyAssociationQuery, error) {
	if p.filter != nil {
		return p.filter(query)
	}
	return query, nil
}

func (p *technologyassociationPager) toCursor(ta *TechnologyAssociation) Cursor {
	return p.order.Field.toCursor(ta)
}

func (p *technologyassociationPager) applyCursors(query *TechnologyAssociationQuery, after, before *Cursor) *TechnologyAssociationQuery {
	for _, predicate := range cursorsToPredicates(
		p.order.Direction, after, before,
		p.order.Field.field, DefaultTechnologyAssociationOrder.Field.field,
	) {
		query = query.Where(predicate)
	}
	return query
}

func (p *technologyassociationPager) applyOrder(query *TechnologyAssociationQuery, reverse bool) *TechnologyAssociationQuery {
	direction := p.order.Direction
	if reverse {
		direction = direction.reverse()
	}
	query = query.Order(direction.orderFunc(p.order.Field.field))
	if p.order.Field != DefaultTechnologyAssociationOrder.Field {
		query = query.Order(direction.orderFunc(DefaultTechnologyAssociationOrder.Field.field))
	}
	return query
}

func (p *technologyassociationPager) orderExpr(reverse bool) sql.Querier {
	direction := p.order.Direction
	if reverse {
		direction = direction.reverse()
	}
	return sql.ExprFunc(func(b *sql.Builder) {
		b.Ident(p.order.Field.field).Pad().WriteString(string(direction))
		if p.order.Field != DefaultTechnologyAssociationOrder.Field {
			b.Comma().Ident(DefaultTechnologyAssociationOrder.Field.field).Pad().WriteString(string(direction))
		}
	})
}

// Paginate executes the query and returns a relay based cursor connection to TechnologyAssociation.
func (ta *TechnologyAssociationQuery) Paginate(
	ctx context.Context, after *Cursor, first *int,
	before *Cursor, last *int, opts ...TechnologyAssociationPaginateOption,
) (*TechnologyAssociationConnection, error) {
	if err := validateFirstLast(first, last); err != nil {
		return nil, err
	}
	pager, err := newTechnologyAssociationPager(opts)
	if err != nil {
		return nil, err
	}
	if ta, err = pager.applyFilter(ta); err != nil {
		return nil, err
	}
	conn := &TechnologyAssociationConnection{Edges: []*TechnologyAssociationEdge{}}
	ignoredEdges := !hasCollectedField(ctx, edgesField)
	if hasCollectedField(ctx, totalCountField) || hasCollectedField(ctx, pageInfoField) {
		hasPagination := after != nil || first != nil || before != nil || last != nil
		if hasPagination || ignoredEdges {
			if conn.TotalCount, err = ta.Count(ctx); err != nil {
				return nil, err
			}
			conn.PageInfo.HasNextPage = first != nil && conn.TotalCount > 0
			conn.PageInfo.HasPreviousPage = last != nil && conn.TotalCount > 0
		}
	}
	if ignoredEdges || (first != nil && *first == 0) || (last != nil && *last == 0) {
		return conn, nil
	}

	ta = pager.applyCursors(ta, after, before)
	ta = pager.applyOrder(ta, last != nil)
	if limit := paginateLimit(first, last); limit != 0 {
		ta.Limit(limit)
	}
	if field := collectedField(ctx, edgesField, nodeField); field != nil {
		if err := ta.collectField(ctx, graphql.GetOperationContext(ctx), *field, []string{edgesField, nodeField}); err != nil {
			return nil, err
		}
	}

	nodes, err := ta.All(ctx)
	if err != nil {
		return nil, err
	}
	conn.build(nodes, pager, after, first, before, last)
	return conn, nil
}

var (
	// TechnologyAssociationOrderFieldType orders TechnologyAssociation by type.
	TechnologyAssociationOrderFieldType = &TechnologyAssociationOrderField{
		field: technologyassociation.FieldType,
		toCursor: func(ta *TechnologyAssociation) Cursor {
			return Cursor{
				ID:    ta.ID,
				Value: ta.Type,
			}
		},
	}
)

// String implement fmt.Stringer interface.
func (f TechnologyAssociationOrderField) String() string {
	var str string
	switch f.field {
	case technologyassociation.FieldType:
		str = "TYPE"
	}
	return str
}

// MarshalGQL implements graphql.Marshaler interface.
func (f TechnologyAssociationOrderField) MarshalGQL(w io.Writer) {
	io.WriteString(w, strconv.Quote(f.String()))
}

// UnmarshalGQL implements graphql.Unmarshaler interface.
func (f *TechnologyAssociationOrderField) UnmarshalGQL(v interface{}) error {
	str, ok := v.(string)
	if !ok {
		return fmt.Errorf("TechnologyAssociationOrderField %T must be a string", v)
	}
	switch str {
	case "TYPE":
		*f = *TechnologyAssociationOrderFieldType
	default:
		return fmt.Errorf("%s is not a valid TechnologyAssociationOrderField", str)
	}
	return nil
}

// TechnologyAssociationOrderField defines the ordering field of TechnologyAssociation.
type TechnologyAssociationOrderField struct {
	field    string
	toCursor func(*TechnologyAssociation) Cursor
}

// TechnologyAssociationOrder defines the ordering of TechnologyAssociation.
type TechnologyAssociationOrder struct {
	Direction OrderDirection                   `json:"direction"`
	Field     *TechnologyAssociationOrderField `json:"field"`
}

// DefaultTechnologyAssociationOrder is the default ordering of TechnologyAssociation.
var DefaultTechnologyAssociationOrder = &TechnologyAssociationOrder{
	Direction: OrderDirectionAsc,
	Field: &TechnologyAssociationOrderField{
		field: technologyassociation.FieldID,
		toCursor: func(ta *TechnologyAssociation) Cursor {
			return Cursor{ID: ta.ID}
		},
	},
}

// ToEdge converts TechnologyAssociation into TechnologyAssociationEdge.
func (ta *TechnologyAssociation) ToEdge(order *TechnologyAssociationOrder) *TechnologyAssociationEdge {
	if order == nil {
		order = DefaultTechnologyAssociationOrder
	}
	return &TechnologyAssociationEdge{
		Node:   ta,
		Cursor: order.Field.toCursor(ta),
	}
}

// UserEdge is the edge representation of User.
type UserEdge struct {
	Node   *User  `json:"node"`
	Cursor Cursor `json:"cursor"`
}

// UserConnection is the connection containing edges to User.
type UserConnection struct {
	Edges      []*UserEdge `json:"edges"`
	PageInfo   PageInfo    `json:"pageInfo"`
	TotalCount int         `json:"totalCount"`
}

func (c *UserConnection) build(nodes []*User, pager *userPager, after *Cursor, first *int, before *Cursor, last *int) {
	c.PageInfo.HasNextPage = before != nil
	c.PageInfo.HasPreviousPage = after != nil
	if first != nil && *first+1 == len(nodes) {
		c.PageInfo.HasNextPage = true
		nodes = nodes[:len(nodes)-1]
	} else if last != nil && *last+1 == len(nodes) {
		c.PageInfo.HasPreviousPage = true
		nodes = nodes[:len(nodes)-1]
	}
	var nodeAt func(int) *User
	if last != nil {
		n := len(nodes) - 1
		nodeAt = func(i int) *User {
			return nodes[n-i]
		}
	} else {
		nodeAt = func(i int) *User {
			return nodes[i]
		}
	}
	c.Edges = make([]*UserEdge, len(nodes))
	for i := range nodes {
		node := nodeAt(i)
		c.Edges[i] = &UserEdge{
			Node:   node,
			Cursor: pager.toCursor(node),
		}
	}
	if l := len(c.Edges); l > 0 {
		c.PageInfo.StartCursor = &c.Edges[0].Cursor
		c.PageInfo.EndCursor = &c.Edges[l-1].Cursor
	}
	if c.TotalCount == 0 {
		c.TotalCount = len(nodes)
	}
}

// UserPaginateOption enables pagination customization.
type UserPaginateOption func(*userPager) error

// WithUserOrder configures pagination ordering.
func WithUserOrder(order *UserOrder) UserPaginateOption {
	if order == nil {
		order = DefaultUserOrder
	}
	o := *order
	return func(pager *userPager) error {
		if err := o.Direction.Validate(); err != nil {
			return err
		}
		if o.Field == nil {
			o.Field = DefaultUserOrder.Field
		}
		pager.order = &o
		return nil
	}
}

// WithUserFilter configures pagination filter.
func WithUserFilter(filter func(*UserQuery) (*UserQuery, error)) UserPaginateOption {
	return func(pager *userPager) error {
		if filter == nil {
			return errors.New("UserQuery filter cannot be nil")
		}
		pager.filter = filter
		return nil
	}
}

type userPager struct {
	order  *UserOrder
	filter func(*UserQuery) (*UserQuery, error)
}

func newUserPager(opts []UserPaginateOption) (*userPager, error) {
	pager := &userPager{}
	for _, opt := range opts {
		if err := opt(pager); err != nil {
			return nil, err
		}
	}
	if pager.order == nil {
		pager.order = DefaultUserOrder
	}
	return pager, nil
}

func (p *userPager) applyFilter(query *UserQuery) (*UserQuery, error) {
	if p.filter != nil {
		return p.filter(query)
	}
	return query, nil
}

func (p *userPager) toCursor(u *User) Cursor {
	return p.order.Field.toCursor(u)
}

func (p *userPager) applyCursors(query *UserQuery, after, before *Cursor) *UserQuery {
	for _, predicate := range cursorsToPredicates(
		p.order.Direction, after, before,
		p.order.Field.field, DefaultUserOrder.Field.field,
	) {
		query = query.Where(predicate)
	}
	return query
}

func (p *userPager) applyOrder(query *UserQuery, reverse bool) *UserQuery {
	direction := p.order.Direction
	if reverse {
		direction = direction.reverse()
	}
	query = query.Order(direction.orderFunc(p.order.Field.field))
	if p.order.Field != DefaultUserOrder.Field {
		query = query.Order(direction.orderFunc(DefaultUserOrder.Field.field))
	}
	return query
}

func (p *userPager) orderExpr(reverse bool) sql.Querier {
	direction := p.order.Direction
	if reverse {
		direction = direction.reverse()
	}
	return sql.ExprFunc(func(b *sql.Builder) {
		b.Ident(p.order.Field.field).Pad().WriteString(string(direction))
		if p.order.Field != DefaultUserOrder.Field {
			b.Comma().Ident(DefaultUserOrder.Field.field).Pad().WriteString(string(direction))
		}
	})
}

// Paginate executes the query and returns a relay based cursor connection to User.
func (u *UserQuery) Paginate(
	ctx context.Context, after *Cursor, first *int,
	before *Cursor, last *int, opts ...UserPaginateOption,
) (*UserConnection, error) {
	if err := validateFirstLast(first, last); err != nil {
		return nil, err
	}
	pager, err := newUserPager(opts)
	if err != nil {
		return nil, err
	}
	if u, err = pager.applyFilter(u); err != nil {
		return nil, err
	}
	conn := &UserConnection{Edges: []*UserEdge{}}
	ignoredEdges := !hasCollectedField(ctx, edgesField)
	if hasCollectedField(ctx, totalCountField) || hasCollectedField(ctx, pageInfoField) {
		hasPagination := after != nil || first != nil || before != nil || last != nil
		if hasPagination || ignoredEdges {
			if conn.TotalCount, err = u.Count(ctx); err != nil {
				return nil, err
			}
			conn.PageInfo.HasNextPage = first != nil && conn.TotalCount > 0
			conn.PageInfo.HasPreviousPage = last != nil && conn.TotalCount > 0
		}
	}
	if ignoredEdges || (first != nil && *first == 0) || (last != nil && *last == 0) {
		return conn, nil
	}

	u = pager.applyCursors(u, after, before)
	u = pager.applyOrder(u, last != nil)
	if limit := paginateLimit(first, last); limit != 0 {
		u.Limit(limit)
	}
	if field := collectedField(ctx, edgesField, nodeField); field != nil {
		if err := u.collectField(ctx, graphql.GetOperationContext(ctx), *field, []string{edgesField, nodeField}); err != nil {
			return nil, err
		}
	}

	nodes, err := u.All(ctx)
	if err != nil {
		return nil, err
	}
	conn.build(nodes, pager, after, first, before, last)
	return conn, nil
}

var (
	// UserOrderFieldUsername orders User by username.
	UserOrderFieldUsername = &UserOrderField{
		field: user.FieldUsername,
		toCursor: func(u *User) Cursor {
			return Cursor{
				ID:    u.ID,
				Value: u.Username,
			}
		},
	}
)

// String implement fmt.Stringer interface.
func (f UserOrderField) String() string {
	var str string
	switch f.field {
	case user.FieldUsername:
		str = "USERNAME"
	}
	return str
}

// MarshalGQL implements graphql.Marshaler interface.
func (f UserOrderField) MarshalGQL(w io.Writer) {
	io.WriteString(w, strconv.Quote(f.String()))
}

// UnmarshalGQL implements graphql.Unmarshaler interface.
func (f *UserOrderField) UnmarshalGQL(v interface{}) error {
	str, ok := v.(string)
	if !ok {
		return fmt.Errorf("UserOrderField %T must be a string", v)
	}
	switch str {
	case "USERNAME":
		*f = *UserOrderFieldUsername
	default:
		return fmt.Errorf("%s is not a valid UserOrderField", str)
	}
	return nil
}

// UserOrderField defines the ordering field of User.
type UserOrderField struct {
	field    string
	toCursor func(*User) Cursor
}

// UserOrder defines the ordering of User.
type UserOrder struct {
	Direction OrderDirection  `json:"direction"`
	Field     *UserOrderField `json:"field"`
}

// DefaultUserOrder is the default ordering of User.
var DefaultUserOrder = &UserOrder{
	Direction: OrderDirectionAsc,
	Field: &UserOrderField{
		field: user.FieldID,
		toCursor: func(u *User) Cursor {
			return Cursor{ID: u.ID}
		},
	},
}

// ToEdge converts User into UserEdge.
func (u *User) ToEdge(order *UserOrder) *UserEdge {
	if order == nil {
		order = DefaultUserOrder
	}
	return &UserEdge{
		Node:   u,
		Cursor: order.Field.toCursor(u),
	}
}