gql_pagination.go

// Code generated by ent, DO NOT EDIT.

package generated

import (
	"context"
	"errors"
	"fmt"
	"io"
	"strconv"

	"entgo.io/contrib/entgql"
	"entgo.io/ent"
	"entgo.io/ent/dialect/sql"
	"github.com/99designs/gqlgen/graphql"
	"github.com/99designs/gqlgen/graphql/errcode"
	"github.com/datumforge/datum/internal/ent/generated/entitlement"
	"github.com/datumforge/datum/internal/ent/generated/group"
	"github.com/datumforge/datum/internal/ent/generated/groupsetting"
	"github.com/datumforge/datum/internal/ent/generated/integration"
	"github.com/datumforge/datum/internal/ent/generated/oauthprovider"
	"github.com/datumforge/datum/internal/ent/generated/ohauthtootoken"
	"github.com/datumforge/datum/internal/ent/generated/organization"
	"github.com/datumforge/datum/internal/ent/generated/organizationsetting"
	"github.com/datumforge/datum/internal/ent/generated/personalaccesstoken"
	"github.com/datumforge/datum/internal/ent/generated/session"
	"github.com/datumforge/datum/internal/ent/generated/user"
	"github.com/datumforge/datum/internal/ent/generated/usersetting"
	"github.com/vektah/gqlparser/v2/gqlerror"
)

// Common entgql types.
type (
	Cursor         = entgql.Cursor[string]
	PageInfo       = entgql.PageInfo[string]
	OrderDirection = entgql.OrderDirection
)

func orderFunc(o OrderDirection, field string) func(*sql.Selector) {
	if o == entgql.OrderDirectionDesc {
		return Desc(field)
	}
	return Asc(field)
}

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
}

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

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

func (c *EntitlementConnection) build(nodes []*Entitlement, pager *entitlementPager, 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) *Entitlement
	if last != nil {
		n := len(nodes) - 1
		nodeAt = func(i int) *Entitlement {
			return nodes[n-i]
		}
	} else {
		nodeAt = func(i int) *Entitlement {
			return nodes[i]
		}
	}
	c.Edges = make([]*EntitlementEdge, len(nodes))
	for i := range nodes {
		node := nodeAt(i)
		c.Edges[i] = &EntitlementEdge{
			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)
	}
}

// EntitlementPaginateOption enables pagination customization.
type EntitlementPaginateOption func(*entitlementPager) error

// WithEntitlementOrder configures pagination ordering.
func WithEntitlementOrder(order *EntitlementOrder) EntitlementPaginateOption {
	if order == nil {
		order = DefaultEntitlementOrder
	}
	o := *order
	return func(pager *entitlementPager) error {
		if err := o.Direction.Validate(); err != nil {
			return err
		}
		if o.Field == nil {
			o.Field = DefaultEntitlementOrder.Field
		}
		pager.order = &o
		return nil
	}
}

// WithEntitlementFilter configures pagination filter.
func WithEntitlementFilter(filter func(*EntitlementQuery) (*EntitlementQuery, error)) EntitlementPaginateOption {
	return func(pager *entitlementPager) error {
		if filter == nil {
			return errors.New("EntitlementQuery filter cannot be nil")
		}
		pager.filter = filter
		return nil
	}
}

type entitlementPager struct {
	reverse bool
	order   *EntitlementOrder
	filter  func(*EntitlementQuery) (*EntitlementQuery, error)
}

func newEntitlementPager(opts []EntitlementPaginateOption, reverse bool) (*entitlementPager, error) {
	pager := &entitlementPager{reverse: reverse}
	for _, opt := range opts {
		if err := opt(pager); err != nil {
			return nil, err
		}
	}
	if pager.order == nil {
		pager.order = DefaultEntitlementOrder
	}
	return pager, nil
}

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

func (p *entitlementPager) toCursor(e *Entitlement) Cursor {
	return p.order.Field.toCursor(e)
}

func (p *entitlementPager) applyCursors(query *EntitlementQuery, after, before *Cursor) (*EntitlementQuery, error) {
	direction := p.order.Direction
	if p.reverse {
		direction = direction.Reverse()
	}
	for _, predicate := range entgql.CursorsPredicate(after, before, DefaultEntitlementOrder.Field.column, p.order.Field.column, direction) {
		query = query.Where(predicate)
	}
	return query, nil
}

func (p *entitlementPager) applyOrder(query *EntitlementQuery) *EntitlementQuery {
	direction := p.order.Direction
	if p.reverse {
		direction = direction.Reverse()
	}
	query = query.Order(p.order.Field.toTerm(direction.OrderTermOption()))
	if p.order.Field != DefaultEntitlementOrder.Field {
		query = query.Order(DefaultEntitlementOrder.Field.toTerm(direction.OrderTermOption()))
	}
	if len(query.ctx.Fields) > 0 {
		query.ctx.AppendFieldOnce(p.order.Field.column)
	}
	return query
}

func (p *entitlementPager) orderExpr(query *EntitlementQuery) sql.Querier {
	direction := p.order.Direction
	if p.reverse {
		direction = direction.Reverse()
	}
	if len(query.ctx.Fields) > 0 {
		query.ctx.AppendFieldOnce(p.order.Field.column)
	}
	return sql.ExprFunc(func(b *sql.Builder) {
		b.Ident(p.order.Field.column).Pad().WriteString(string(direction))
		if p.order.Field != DefaultEntitlementOrder.Field {
			b.Comma().Ident(DefaultEntitlementOrder.Field.column).Pad().WriteString(string(direction))
		}
	})
}

// Paginate executes the query and returns a relay based cursor connection to Entitlement.
func (e *EntitlementQuery) Paginate(
	ctx context.Context, after *Cursor, first *int,
	before *Cursor, last *int, opts ...EntitlementPaginateOption,
) (*EntitlementConnection, error) {
	if err := validateFirstLast(first, last); err != nil {
		return nil, err
	}
	pager, err := newEntitlementPager(opts, last != nil)
	if err != nil {
		return nil, err
	}
	if e, err = pager.applyFilter(e); err != nil {
		return nil, err
	}
	conn := &EntitlementConnection{Edges: []*EntitlementEdge{}}
	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 = e.Clone().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
	}
	if e, err = pager.applyCursors(e, after, before); err != nil {
		return nil, err
	}
	if limit := paginateLimit(first, last); limit != 0 {
		e.Limit(limit)
	}
	if field := collectedField(ctx, edgesField, nodeField); field != nil {
		if err := e.collectField(ctx, graphql.GetOperationContext(ctx), *field, []string{edgesField, nodeField}); err != nil {
			return nil, err
		}
	}
	e = pager.applyOrder(e)
	nodes, err := e.All(ctx)
	if err != nil {
		return nil, err
	}
	conn.build(nodes, pager, after, first, before, last)
	return conn, nil
}

// EntitlementOrderField defines the ordering field of Entitlement.
type EntitlementOrderField struct {
	// Value extracts the ordering value from the given Entitlement.
	Value    func(*Entitlement) (ent.Value, error)
	column   string // field or computed.
	toTerm   func(...sql.OrderTermOption) entitlement.OrderOption
	toCursor func(*Entitlement) Cursor
}

// EntitlementOrder defines the ordering of Entitlement.
type EntitlementOrder struct {
	Direction OrderDirection         `json:"direction"`
	Field     *EntitlementOrderField `json:"field"`
}

// DefaultEntitlementOrder is the default ordering of Entitlement.
var DefaultEntitlementOrder = &EntitlementOrder{
	Direction: entgql.OrderDirectionAsc,
	Field: &EntitlementOrderField{
		Value: func(e *Entitlement) (ent.Value, error) {
			return e.ID, nil
		},
		column: entitlement.FieldID,
		toTerm: entitlement.ByID,
		toCursor: func(e *Entitlement) Cursor {
			return Cursor{ID: e.ID}
		},
	},
}

// ToEdge converts Entitlement into EntitlementEdge.
func (e *Entitlement) ToEdge(order *EntitlementOrder) *EntitlementEdge {
	if order == nil {
		order = DefaultEntitlementOrder
	}
	return &EntitlementEdge{
		Node:   e,
		Cursor: order.Field.toCursor(e),
	}
}

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

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

func (c *GroupConnection) build(nodes []*Group, pager *groupPager, 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) *Group
	if last != nil {
		n := len(nodes) - 1
		nodeAt = func(i int) *Group {
			return nodes[n-i]
		}
	} else {
		nodeAt = func(i int) *Group {
			return nodes[i]
		}
	}
	c.Edges = make([]*GroupEdge, len(nodes))
	for i := range nodes {
		node := nodeAt(i)
		c.Edges[i] = &GroupEdge{
			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)
	}
}

// GroupPaginateOption enables pagination customization.
type GroupPaginateOption func(*groupPager) error

// WithGroupOrder configures pagination ordering.
func WithGroupOrder(order *GroupOrder) GroupPaginateOption {
	if order == nil {
		order = DefaultGroupOrder
	}
	o := *order
	return func(pager *groupPager) error {
		if err := o.Direction.Validate(); err != nil {
			return err
		}
		if o.Field == nil {
			o.Field = DefaultGroupOrder.Field
		}
		pager.order = &o
		return nil
	}
}

// WithGroupFilter configures pagination filter.
func WithGroupFilter(filter func(*GroupQuery) (*GroupQuery, error)) GroupPaginateOption {
	return func(pager *groupPager) error {
		if filter == nil {
			return errors.New("GroupQuery filter cannot be nil")
		}
		pager.filter = filter
		return nil
	}
}

type groupPager struct {
	reverse bool
	order   *GroupOrder
	filter  func(*GroupQuery) (*GroupQuery, error)
}

func newGroupPager(opts []GroupPaginateOption, reverse bool) (*groupPager, error) {
	pager := &groupPager{reverse: reverse}
	for _, opt := range opts {
		if err := opt(pager); err != nil {
			return nil, err
		}
	}
	if pager.order == nil {
		pager.order = DefaultGroupOrder
	}
	return pager, nil
}

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

func (p *groupPager) toCursor(gr *Group) Cursor {
	return p.order.Field.toCursor(gr)
}

func (p *groupPager) applyCursors(query *GroupQuery, after, before *Cursor) (*GroupQuery, error) {
	direction := p.order.Direction
	if p.reverse {
		direction = direction.Reverse()
	}
	for _, predicate := range entgql.CursorsPredicate(after, before, DefaultGroupOrder.Field.column, p.order.Field.column, direction) {
		query = query.Where(predicate)
	}
	return query, nil
}

func (p *groupPager) applyOrder(query *GroupQuery) *GroupQuery {
	direction := p.order.Direction
	if p.reverse {
		direction = direction.Reverse()
	}
	query = query.Order(p.order.Field.toTerm(direction.OrderTermOption()))
	if p.order.Field != DefaultGroupOrder.Field {
		query = query.Order(DefaultGroupOrder.Field.toTerm(direction.OrderTermOption()))
	}
	if len(query.ctx.Fields) > 0 {
		query.ctx.AppendFieldOnce(p.order.Field.column)
	}
	return query
}

func (p *groupPager) orderExpr(query *GroupQuery) sql.Querier {
	direction := p.order.Direction
	if p.reverse {
		direction = direction.Reverse()
	}
	if len(query.ctx.Fields) > 0 {
		query.ctx.AppendFieldOnce(p.order.Field.column)
	}
	return sql.ExprFunc(func(b *sql.Builder) {
		b.Ident(p.order.Field.column).Pad().WriteString(string(direction))
		if p.order.Field != DefaultGroupOrder.Field {
			b.Comma().Ident(DefaultGroupOrder.Field.column).Pad().WriteString(string(direction))
		}
	})
}

// Paginate executes the query and returns a relay based cursor connection to Group.
func (gr *GroupQuery) Paginate(
	ctx context.Context, after *Cursor, first *int,
	before *Cursor, last *int, opts ...GroupPaginateOption,
) (*GroupConnection, error) {
	if err := validateFirstLast(first, last); err != nil {
		return nil, err
	}
	pager, err := newGroupPager(opts, last != nil)
	if err != nil {
		return nil, err
	}
	if gr, err = pager.applyFilter(gr); err != nil {
		return nil, err
	}
	conn := &GroupConnection{Edges: []*GroupEdge{}}
	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 = gr.Clone().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
	}
	if gr, err = pager.applyCursors(gr, after, before); err != nil {
		return nil, err
	}
	if limit := paginateLimit(first, last); limit != 0 {
		gr.Limit(limit)
	}
	if field := collectedField(ctx, edgesField, nodeField); field != nil {
		if err := gr.collectField(ctx, graphql.GetOperationContext(ctx), *field, []string{edgesField, nodeField}); err != nil {
			return nil, err
		}
	}
	gr = pager.applyOrder(gr)
	nodes, err := gr.All(ctx)
	if err != nil {
		return nil, err
	}
	conn.build(nodes, pager, after, first, before, last)
	return conn, nil
}

var (
	// GroupOrderFieldName orders Group by name.
	GroupOrderFieldName = &GroupOrderField{
		Value: func(gr *Group) (ent.Value, error) {
			return gr.Name, nil
		},
		column: group.FieldName,
		toTerm: group.ByName,
		toCursor: func(gr *Group) Cursor {
			return Cursor{
				ID:    gr.ID,
				Value: gr.Name,
			}
		},
	}
	// GroupOrderFieldDisplayName orders Group by display_name.
	GroupOrderFieldDisplayName = &GroupOrderField{
		Value: func(gr *Group) (ent.Value, error) {
			return gr.DisplayName, nil
		},
		column: group.FieldDisplayName,
		toTerm: group.ByDisplayName,
		toCursor: func(gr *Group) Cursor {
			return Cursor{
				ID:    gr.ID,
				Value: gr.DisplayName,
			}
		},
	}
)

// String implement fmt.Stringer interface.
func (f GroupOrderField) String() string {
	var str string
	switch f.column {
	case GroupOrderFieldName.column:
		str = "name"
	case GroupOrderFieldDisplayName.column:
		str = "display_name"
	}
	return str
}

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

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

// GroupOrderField defines the ordering field of Group.
type GroupOrderField struct {
	// Value extracts the ordering value from the given Group.
	Value    func(*Group) (ent.Value, error)
	column   string // field or computed.
	toTerm   func(...sql.OrderTermOption) group.OrderOption
	toCursor func(*Group) Cursor
}

// GroupOrder defines the ordering of Group.
type GroupOrder struct {
	Direction OrderDirection   `json:"direction"`
	Field     *GroupOrderField `json:"field"`
}

// DefaultGroupOrder is the default ordering of Group.
var DefaultGroupOrder = &GroupOrder{
	Direction: entgql.OrderDirectionAsc,
	Field: &GroupOrderField{
		Value: func(gr *Group) (ent.Value, error) {
			return gr.ID, nil
		},
		column: group.FieldID,
		toTerm: group.ByID,
		toCursor: func(gr *Group) Cursor {
			return Cursor{ID: gr.ID}
		},
	},
}

// ToEdge converts Group into GroupEdge.
func (gr *Group) ToEdge(order *GroupOrder) *GroupEdge {
	if order == nil {
		order = DefaultGroupOrder
	}
	return &GroupEdge{
		Node:   gr,
		Cursor: order.Field.toCursor(gr),
	}
}

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

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

func (c *GroupSettingConnection) build(nodes []*GroupSetting, pager *groupsettingPager, 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) *GroupSetting
	if last != nil {
		n := len(nodes) - 1
		nodeAt = func(i int) *GroupSetting {
			return nodes[n-i]
		}
	} else {
		nodeAt = func(i int) *GroupSetting {
			return nodes[i]
		}
	}
	c.Edges = make([]*GroupSettingEdge, len(nodes))
	for i := range nodes {
		node := nodeAt(i)
		c.Edges[i] = &GroupSettingEdge{
			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)
	}
}

// GroupSettingPaginateOption enables pagination customization.
type GroupSettingPaginateOption func(*groupsettingPager) error

// WithGroupSettingOrder configures pagination ordering.
func WithGroupSettingOrder(order *GroupSettingOrder) GroupSettingPaginateOption {
	if order == nil {
		order = DefaultGroupSettingOrder
	}
	o := *order
	return func(pager *groupsettingPager) error {
		if err := o.Direction.Validate(); err != nil {
			return err
		}
		if o.Field == nil {
			o.Field = DefaultGroupSettingOrder.Field
		}
		pager.order = &o
		return nil
	}
}

// WithGroupSettingFilter configures pagination filter.
func WithGroupSettingFilter(filter func(*GroupSettingQuery) (*GroupSettingQuery, error)) GroupSettingPaginateOption {
	return func(pager *groupsettingPager) error {
		if filter == nil {
			return errors.New("GroupSettingQuery filter cannot be nil")
		}
		pager.filter = filter
		return nil
	}
}

type groupsettingPager struct {
	reverse bool
	order   *GroupSettingOrder
	filter  func(*GroupSettingQuery) (*GroupSettingQuery, error)
}

func newGroupSettingPager(opts []GroupSettingPaginateOption, reverse bool) (*groupsettingPager, error) {
	pager := &groupsettingPager{reverse: reverse}
	for _, opt := range opts {
		if err := opt(pager); err != nil {
			return nil, err
		}
	}
	if pager.order == nil {
		pager.order = DefaultGroupSettingOrder
	}
	return pager, nil
}

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

func (p *groupsettingPager) toCursor(gs *GroupSetting) Cursor {
	return p.order.Field.toCursor(gs)
}

func (p *groupsettingPager) applyCursors(query *GroupSettingQuery, after, before *Cursor) (*GroupSettingQuery, error) {
	direction := p.order.Direction
	if p.reverse {
		direction = direction.Reverse()
	}
	for _, predicate := range entgql.CursorsPredicate(after, before, DefaultGroupSettingOrder.Field.column, p.order.Field.column, direction) {
		query = query.Where(predicate)
	}
	return query, nil
}

func (p *groupsettingPager) applyOrder(query *GroupSettingQuery) *GroupSettingQuery {
	direction := p.order.Direction
	if p.reverse {
		direction = direction.Reverse()
	}
	query = query.Order(p.order.Field.toTerm(direction.OrderTermOption()))
	if p.order.Field != DefaultGroupSettingOrder.Field {
		query = query.Order(DefaultGroupSettingOrder.Field.toTerm(direction.OrderTermOption()))
	}
	if len(query.ctx.Fields) > 0 {
		query.ctx.AppendFieldOnce(p.order.Field.column)
	}
	return query
}

func (p *groupsettingPager) orderExpr(query *GroupSettingQuery) sql.Querier {
	direction := p.order.Direction
	if p.reverse {
		direction = direction.Reverse()
	}
	if len(query.ctx.Fields) > 0 {
		query.ctx.AppendFieldOnce(p.order.Field.column)
	}
	return sql.ExprFunc(func(b *sql.Builder) {
		b.Ident(p.order.Field.column).Pad().WriteString(string(direction))
		if p.order.Field != DefaultGroupSettingOrder.Field {
			b.Comma().Ident(DefaultGroupSettingOrder.Field.column).Pad().WriteString(string(direction))
		}
	})
}

// Paginate executes the query and returns a relay based cursor connection to GroupSetting.
func (gs *GroupSettingQuery) Paginate(
	ctx context.Context, after *Cursor, first *int,
	before *Cursor, last *int, opts ...GroupSettingPaginateOption,
) (*GroupSettingConnection, error) {
	if err := validateFirstLast(first, last); err != nil {
		return nil, err
	}
	pager, err := newGroupSettingPager(opts, last != nil)
	if err != nil {
		return nil, err
	}
	if gs, err = pager.applyFilter(gs); err != nil {
		return nil, err
	}
	conn := &GroupSettingConnection{Edges: []*GroupSettingEdge{}}
	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 = gs.Clone().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
	}
	if gs, err = pager.applyCursors(gs, after, before); err != nil {
		return nil, err
	}
	if limit := paginateLimit(first, last); limit != 0 {
		gs.Limit(limit)
	}
	if field := collectedField(ctx, edgesField, nodeField); field != nil {
		if err := gs.collectField(ctx, graphql.GetOperationContext(ctx), *field, []string{edgesField, nodeField}); err != nil {
			return nil, err
		}
	}
	gs = pager.applyOrder(gs)
	nodes, err := gs.All(ctx)
	if err != nil {
		return nil, err
	}
	conn.build(nodes, pager, after, first, before, last)
	return conn, nil
}

// GroupSettingOrderField defines the ordering field of GroupSetting.
type GroupSettingOrderField struct {
	// Value extracts the ordering value from the given GroupSetting.
	Value    func(*GroupSetting) (ent.Value, error)
	column   string // field or computed.
	toTerm   func(...sql.OrderTermOption) groupsetting.OrderOption
	toCursor func(*GroupSetting) Cursor
}

// GroupSettingOrder defines the ordering of GroupSetting.
type GroupSettingOrder struct {
	Direction OrderDirection          `json:"direction"`
	Field     *GroupSettingOrderField `json:"field"`
}

// DefaultGroupSettingOrder is the default ordering of GroupSetting.
var DefaultGroupSettingOrder = &GroupSettingOrder{
	Direction: entgql.OrderDirectionAsc,
	Field: &GroupSettingOrderField{
		Value: func(gs *GroupSetting) (ent.Value, error) {
			return gs.ID, nil
		},
		column: groupsetting.FieldID,
		toTerm: groupsetting.ByID,
		toCursor: func(gs *GroupSetting) Cursor {
			return Cursor{ID: gs.ID}
		},
	},
}

// ToEdge converts GroupSetting into GroupSettingEdge.
func (gs *GroupSetting) ToEdge(order *GroupSettingOrder) *GroupSettingEdge {
	if order == nil {
		order = DefaultGroupSettingOrder
	}
	return &GroupSettingEdge{
		Node:   gs,
		Cursor: order.Field.toCursor(gs),
	}
}

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

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

func (c *IntegrationConnection) build(nodes []*Integration, pager *integrationPager, 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) *Integration
	if last != nil {
		n := len(nodes) - 1
		nodeAt = func(i int) *Integration {
			return nodes[n-i]
		}
	} else {
		nodeAt = func(i int) *Integration {
			return nodes[i]
		}
	}
	c.Edges = make([]*IntegrationEdge, len(nodes))
	for i := range nodes {
		node := nodeAt(i)
		c.Edges[i] = &IntegrationEdge{
			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)
	}
}

// IntegrationPaginateOption enables pagination customization.
type IntegrationPaginateOption func(*integrationPager) error

// WithIntegrationOrder configures pagination ordering.
func WithIntegrationOrder(order *IntegrationOrder) IntegrationPaginateOption {
	if order == nil {
		order = DefaultIntegrationOrder
	}
	o := *order
	return func(pager *integrationPager) error {
		if err := o.Direction.Validate(); err != nil {
			return err
		}
		if o.Field == nil {
			o.Field = DefaultIntegrationOrder.Field
		}
		pager.order = &o
		return nil
	}
}

// WithIntegrationFilter configures pagination filter.
func WithIntegrationFilter(filter func(*IntegrationQuery) (*IntegrationQuery, error)) IntegrationPaginateOption {
	return func(pager *integrationPager) error {
		if filter == nil {
			return errors.New("IntegrationQuery filter cannot be nil")
		}
		pager.filter = filter
		return nil
	}
}

type integrationPager struct {
	reverse bool
	order   *IntegrationOrder
	filter  func(*IntegrationQuery) (*IntegrationQuery, error)
}

func newIntegrationPager(opts []IntegrationPaginateOption, reverse bool) (*integrationPager, error) {
	pager := &integrationPager{reverse: reverse}
	for _, opt := range opts {
		if err := opt(pager); err != nil {
			return nil, err
		}
	}
	if pager.order == nil {
		pager.order = DefaultIntegrationOrder
	}
	return pager, nil
}

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

func (p *integrationPager) toCursor(i *Integration) Cursor {
	return p.order.Field.toCursor(i)
}

func (p *integrationPager) applyCursors(query *IntegrationQuery, after, before *Cursor) (*IntegrationQuery, error) {
	direction := p.order.Direction
	if p.reverse {
		direction = direction.Reverse()
	}
	for _, predicate := range entgql.CursorsPredicate(after, before, DefaultIntegrationOrder.Field.column, p.order.Field.column, direction) {
		query = query.Where(predicate)
	}
	return query, nil
}

func (p *integrationPager) applyOrder(query *IntegrationQuery) *IntegrationQuery {
	direction := p.order.Direction
	if p.reverse {
		direction = direction.Reverse()
	}
	query = query.Order(p.order.Field.toTerm(direction.OrderTermOption()))
	if p.order.Field != DefaultIntegrationOrder.Field {
		query = query.Order(DefaultIntegrationOrder.Field.toTerm(direction.OrderTermOption()))
	}
	if len(query.ctx.Fields) > 0 {
		query.ctx.AppendFieldOnce(p.order.Field.column)
	}
	return query
}

func (p *integrationPager) orderExpr(query *IntegrationQuery) sql.Querier {
	direction := p.order.Direction
	if p.reverse {
		direction = direction.Reverse()
	}
	if len(query.ctx.Fields) > 0 {
		query.ctx.AppendFieldOnce(p.order.Field.column)
	}
	return sql.ExprFunc(func(b *sql.Builder) {
		b.Ident(p.order.Field.column).Pad().WriteString(string(direction))
		if p.order.Field != DefaultIntegrationOrder.Field {
			b.Comma().Ident(DefaultIntegrationOrder.Field.column).Pad().WriteString(string(direction))
		}
	})
}

// Paginate executes the query and returns a relay based cursor connection to Integration.
func (i *IntegrationQuery) Paginate(
	ctx context.Context, after *Cursor, first *int,
	before *Cursor, last *int, opts ...IntegrationPaginateOption,
) (*IntegrationConnection, error) {
	if err := validateFirstLast(first, last); err != nil {
		return nil, err
	}
	pager, err := newIntegrationPager(opts, last != nil)
	if err != nil {
		return nil, err
	}
	if i, err = pager.applyFilter(i); err != nil {
		return nil, err
	}
	conn := &IntegrationConnection{Edges: []*IntegrationEdge{}}
	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 = i.Clone().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
	}
	if i, err = pager.applyCursors(i, after, before); err != nil {
		return nil, err
	}
	if limit := paginateLimit(first, last); limit != 0 {
		i.Limit(limit)
	}
	if field := collectedField(ctx, edgesField, nodeField); field != nil {
		if err := i.collectField(ctx, graphql.GetOperationContext(ctx), *field, []string{edgesField, nodeField}); err != nil {
			return nil, err
		}
	}
	i = pager.applyOrder(i)
	nodes, err := i.All(ctx)
	if err != nil {
		return nil, err
	}
	conn.build(nodes, pager, after, first, before, last)
	return conn, nil
}

var (
	// IntegrationOrderFieldName orders Integration by name.
	IntegrationOrderFieldName = &IntegrationOrderField{
		Value: func(i *Integration) (ent.Value, error) {
			return i.Name, nil
		},
		column: integration.FieldName,
		toTerm: integration.ByName,
		toCursor: func(i *Integration) Cursor {
			return Cursor{
				ID:    i.ID,
				Value: i.Name,
			}
		},
	}
	// IntegrationOrderFieldKind orders Integration by kind.
	IntegrationOrderFieldKind = &IntegrationOrderField{
		Value: func(i *Integration) (ent.Value, error) {
			return i.Kind, nil
		},
		column: integration.FieldKind,
		toTerm: integration.ByKind,
		toCursor: func(i *Integration) Cursor {
			return Cursor{
				ID:    i.ID,
				Value: i.Kind,
			}
		},
	}
)

// String implement fmt.Stringer interface.
func (f IntegrationOrderField) String() string {
	var str string
	switch f.column {
	case IntegrationOrderFieldName.column:
		str = "name"
	case IntegrationOrderFieldKind.column:
		str = "kind"
	}
	return str
}

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

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

// IntegrationOrderField defines the ordering field of Integration.
type IntegrationOrderField struct {
	// Value extracts the ordering value from the given Integration.
	Value    func(*Integration) (ent.Value, error)
	column   string // field or computed.
	toTerm   func(...sql.OrderTermOption) integration.OrderOption
	toCursor func(*Integration) Cursor
}

// IntegrationOrder defines the ordering of Integration.
type IntegrationOrder struct {
	Direction OrderDirection         `json:"direction"`
	Field     *IntegrationOrderField `json:"field"`
}

// DefaultIntegrationOrder is the default ordering of Integration.
var DefaultIntegrationOrder = &IntegrationOrder{
	Direction: entgql.OrderDirectionAsc,
	Field: &IntegrationOrderField{
		Value: func(i *Integration) (ent.Value, error) {
			return i.ID, nil
		},
		column: integration.FieldID,
		toTerm: integration.ByID,
		toCursor: func(i *Integration) Cursor {
			return Cursor{ID: i.ID}
		},
	},
}

// ToEdge converts Integration into IntegrationEdge.
func (i *Integration) ToEdge(order *IntegrationOrder) *IntegrationEdge {
	if order == nil {
		order = DefaultIntegrationOrder
	}
	return &IntegrationEdge{
		Node:   i,
		Cursor: order.Field.toCursor(i),
	}
}

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

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

func (c *OauthProviderConnection) build(nodes []*OauthProvider, pager *oauthproviderPager, 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) *OauthProvider
	if last != nil {
		n := len(nodes) - 1
		nodeAt = func(i int) *OauthProvider {
			return nodes[n-i]
		}
	} else {
		nodeAt = func(i int) *OauthProvider {
			return nodes[i]
		}
	}
	c.Edges = make([]*OauthProviderEdge, len(nodes))
	for i := range nodes {
		node := nodeAt(i)
		c.Edges[i] = &OauthProviderEdge{
			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)
	}
}

// OauthProviderPaginateOption enables pagination customization.
type OauthProviderPaginateOption func(*oauthproviderPager) error

// WithOauthProviderOrder configures pagination ordering.
func WithOauthProviderOrder(order *OauthProviderOrder) OauthProviderPaginateOption {
	if order == nil {
		order = DefaultOauthProviderOrder
	}
	o := *order
	return func(pager *oauthproviderPager) error {
		if err := o.Direction.Validate(); err != nil {
			return err
		}
		if o.Field == nil {
			o.Field = DefaultOauthProviderOrder.Field
		}
		pager.order = &o
		return nil
	}
}

// WithOauthProviderFilter configures pagination filter.
func WithOauthProviderFilter(filter func(*OauthProviderQuery) (*OauthProviderQuery, error)) OauthProviderPaginateOption {
	return func(pager *oauthproviderPager) error {
		if filter == nil {
			return errors.New("OauthProviderQuery filter cannot be nil")
		}
		pager.filter = filter
		return nil
	}
}

type oauthproviderPager struct {
	reverse bool
	order   *OauthProviderOrder
	filter  func(*OauthProviderQuery) (*OauthProviderQuery, error)
}

func newOauthProviderPager(opts []OauthProviderPaginateOption, reverse bool) (*oauthproviderPager, error) {
	pager := &oauthproviderPager{reverse: reverse}
	for _, opt := range opts {
		if err := opt(pager); err != nil {
			return nil, err
		}
	}
	if pager.order == nil {
		pager.order = DefaultOauthProviderOrder
	}
	return pager, nil
}

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

func (p *oauthproviderPager) toCursor(op *OauthProvider) Cursor {
	return p.order.Field.toCursor(op)
}

func (p *oauthproviderPager) applyCursors(query *OauthProviderQuery, after, before *Cursor) (*OauthProviderQuery, error) {
	direction := p.order.Direction
	if p.reverse {
		direction = direction.Reverse()
	}
	for _, predicate := range entgql.CursorsPredicate(after, before, DefaultOauthProviderOrder.Field.column, p.order.Field.column, direction) {
		query = query.Where(predicate)
	}
	return query, nil
}

func (p *oauthproviderPager) applyOrder(query *OauthProviderQuery) *OauthProviderQuery {
	direction := p.order.Direction
	if p.reverse {
		direction = direction.Reverse()
	}
	query = query.Order(p.order.Field.toTerm(direction.OrderTermOption()))
	if p.order.Field != DefaultOauthProviderOrder.Field {
		query = query.Order(DefaultOauthProviderOrder.Field.toTerm(direction.OrderTermOption()))
	}
	if len(query.ctx.Fields) > 0 {
		query.ctx.AppendFieldOnce(p.order.Field.column)
	}
	return query
}

func (p *oauthproviderPager) orderExpr(query *OauthProviderQuery) sql.Querier {
	direction := p.order.Direction
	if p.reverse {
		direction = direction.Reverse()
	}
	if len(query.ctx.Fields) > 0 {
		query.ctx.AppendFieldOnce(p.order.Field.column)
	}
	return sql.ExprFunc(func(b *sql.Builder) {
		b.Ident(p.order.Field.column).Pad().WriteString(string(direction))
		if p.order.Field != DefaultOauthProviderOrder.Field {
			b.Comma().Ident(DefaultOauthProviderOrder.Field.column).Pad().WriteString(string(direction))
		}
	})
}

// Paginate executes the query and returns a relay based cursor connection to OauthProvider.
func (op *OauthProviderQuery) Paginate(
	ctx context.Context, after *Cursor, first *int,
	before *Cursor, last *int, opts ...OauthProviderPaginateOption,
) (*OauthProviderConnection, error) {
	if err := validateFirstLast(first, last); err != nil {
		return nil, err
	}
	pager, err := newOauthProviderPager(opts, last != nil)
	if err != nil {
		return nil, err
	}
	if op, err = pager.applyFilter(op); err != nil {
		return nil, err
	}
	conn := &OauthProviderConnection{Edges: []*OauthProviderEdge{}}
	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 = op.Clone().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
	}
	if op, err = pager.applyCursors(op, after, before); err != nil {
		return nil, err
	}
	if limit := paginateLimit(first, last); limit != 0 {
		op.Limit(limit)
	}
	if field := collectedField(ctx, edgesField, nodeField); field != nil {
		if err := op.collectField(ctx, graphql.GetOperationContext(ctx), *field, []string{edgesField, nodeField}); err != nil {
			return nil, err
		}
	}
	op = pager.applyOrder(op)
	nodes, err := op.All(ctx)
	if err != nil {
		return nil, err
	}
	conn.build(nodes, pager, after, first, before, last)
	return conn, nil
}

// OauthProviderOrderField defines the ordering field of OauthProvider.
type OauthProviderOrderField struct {
	// Value extracts the ordering value from the given OauthProvider.
	Value    func(*OauthProvider) (ent.Value, error)
	column   string // field or computed.
	toTerm   func(...sql.OrderTermOption) oauthprovider.OrderOption
	toCursor func(*OauthProvider) Cursor
}

// OauthProviderOrder defines the ordering of OauthProvider.
type OauthProviderOrder struct {
	Direction OrderDirection           `json:"direction"`
	Field     *OauthProviderOrderField `json:"field"`
}

// DefaultOauthProviderOrder is the default ordering of OauthProvider.
var DefaultOauthProviderOrder = &OauthProviderOrder{
	Direction: entgql.OrderDirectionAsc,
	Field: &OauthProviderOrderField{
		Value: func(op *OauthProvider) (ent.Value, error) {
			return op.ID, nil
		},
		column: oauthprovider.FieldID,
		toTerm: oauthprovider.ByID,
		toCursor: func(op *OauthProvider) Cursor {
			return Cursor{ID: op.ID}
		},
	},
}

// ToEdge converts OauthProvider into OauthProviderEdge.
func (op *OauthProvider) ToEdge(order *OauthProviderOrder) *OauthProviderEdge {
	if order == nil {
		order = DefaultOauthProviderOrder
	}
	return &OauthProviderEdge{
		Node:   op,
		Cursor: order.Field.toCursor(op),
	}
}

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

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

func (c *OhAuthTooTokenConnection) build(nodes []*OhAuthTooToken, pager *ohauthtootokenPager, 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) *OhAuthTooToken
	if last != nil {
		n := len(nodes) - 1
		nodeAt = func(i int) *OhAuthTooToken {
			return nodes[n-i]
		}
	} else {
		nodeAt = func(i int) *OhAuthTooToken {
			return nodes[i]
		}
	}
	c.Edges = make([]*OhAuthTooTokenEdge, len(nodes))
	for i := range nodes {
		node := nodeAt(i)
		c.Edges[i] = &OhAuthTooTokenEdge{
			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)
	}
}

// OhAuthTooTokenPaginateOption enables pagination customization.
type OhAuthTooTokenPaginateOption func(*ohauthtootokenPager) error

// WithOhAuthTooTokenOrder configures pagination ordering.
func WithOhAuthTooTokenOrder(order *OhAuthTooTokenOrder) OhAuthTooTokenPaginateOption {
	if order == nil {
		order = DefaultOhAuthTooTokenOrder
	}
	o := *order
	return func(pager *ohauthtootokenPager) error {
		if err := o.Direction.Validate(); err != nil {
			return err
		}
		if o.Field == nil {
			o.Field = DefaultOhAuthTooTokenOrder.Field
		}
		pager.order = &o
		return nil
	}
}

// WithOhAuthTooTokenFilter configures pagination filter.
func WithOhAuthTooTokenFilter(filter func(*OhAuthTooTokenQuery) (*OhAuthTooTokenQuery, error)) OhAuthTooTokenPaginateOption {
	return func(pager *ohauthtootokenPager) error {
		if filter == nil {
			return errors.New("OhAuthTooTokenQuery filter cannot be nil")
		}
		pager.filter = filter
		return nil
	}
}

type ohauthtootokenPager struct {
	reverse bool
	order   *OhAuthTooTokenOrder
	filter  func(*OhAuthTooTokenQuery) (*OhAuthTooTokenQuery, error)
}

func newOhAuthTooTokenPager(opts []OhAuthTooTokenPaginateOption, reverse bool) (*ohauthtootokenPager, error) {
	pager := &ohauthtootokenPager{reverse: reverse}
	for _, opt := range opts {
		if err := opt(pager); err != nil {
			return nil, err
		}
	}
	if pager.order == nil {
		pager.order = DefaultOhAuthTooTokenOrder
	}
	return pager, nil
}

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

func (p *ohauthtootokenPager) toCursor(oatt *OhAuthTooToken) Cursor {
	return p.order.Field.toCursor(oatt)
}

func (p *ohauthtootokenPager) applyCursors(query *OhAuthTooTokenQuery, after, before *Cursor) (*OhAuthTooTokenQuery, error) {
	direction := p.order.Direction
	if p.reverse {
		direction = direction.Reverse()
	}
	for _, predicate := range entgql.CursorsPredicate(after, before, DefaultOhAuthTooTokenOrder.Field.column, p.order.Field.column, direction) {
		query = query.Where(predicate)
	}
	return query, nil
}

func (p *ohauthtootokenPager) applyOrder(query *OhAuthTooTokenQuery) *OhAuthTooTokenQuery {
	direction := p.order.Direction
	if p.reverse {
		direction = direction.Reverse()
	}
	query = query.Order(p.order.Field.toTerm(direction.OrderTermOption()))
	if p.order.Field != DefaultOhAuthTooTokenOrder.Field {
		query = query.Order(DefaultOhAuthTooTokenOrder.Field.toTerm(direction.OrderTermOption()))
	}
	if len(query.ctx.Fields) > 0 {
		query.ctx.AppendFieldOnce(p.order.Field.column)
	}
	return query
}

func (p *ohauthtootokenPager) orderExpr(query *OhAuthTooTokenQuery) sql.Querier {
	direction := p.order.Direction
	if p.reverse {
		direction = direction.Reverse()
	}
	if len(query.ctx.Fields) > 0 {
		query.ctx.AppendFieldOnce(p.order.Field.column)
	}
	return sql.ExprFunc(func(b *sql.Builder) {
		b.Ident(p.order.Field.column).Pad().WriteString(string(direction))
		if p.order.Field != DefaultOhAuthTooTokenOrder.Field {
			b.Comma().Ident(DefaultOhAuthTooTokenOrder.Field.column).Pad().WriteString(string(direction))
		}
	})
}

// Paginate executes the query and returns a relay based cursor connection to OhAuthTooToken.
func (oatt *OhAuthTooTokenQuery) Paginate(
	ctx context.Context, after *Cursor, first *int,
	before *Cursor, last *int, opts ...OhAuthTooTokenPaginateOption,
) (*OhAuthTooTokenConnection, error) {
	if err := validateFirstLast(first, last); err != nil {
		return nil, err
	}
	pager, err := newOhAuthTooTokenPager(opts, last != nil)
	if err != nil {
		return nil, err
	}
	if oatt, err = pager.applyFilter(oatt); err != nil {
		return nil, err
	}
	conn := &OhAuthTooTokenConnection{Edges: []*OhAuthTooTokenEdge{}}
	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 = oatt.Clone().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
	}
	if oatt, err = pager.applyCursors(oatt, after, before); err != nil {
		return nil, err
	}
	if limit := paginateLimit(first, last); limit != 0 {
		oatt.Limit(limit)
	}
	if field := collectedField(ctx, edgesField, nodeField); field != nil {
		if err := oatt.collectField(ctx, graphql.GetOperationContext(ctx), *field, []string{edgesField, nodeField}); err != nil {
			return nil, err
		}
	}
	oatt = pager.applyOrder(oatt)
	nodes, err := oatt.All(ctx)
	if err != nil {
		return nil, err
	}
	conn.build(nodes, pager, after, first, before, last)
	return conn, nil
}

// OhAuthTooTokenOrderField defines the ordering field of OhAuthTooToken.
type OhAuthTooTokenOrderField struct {
	// Value extracts the ordering value from the given OhAuthTooToken.
	Value    func(*OhAuthTooToken) (ent.Value, error)
	column   string // field or computed.
	toTerm   func(...sql.OrderTermOption) ohauthtootoken.OrderOption
	toCursor func(*OhAuthTooToken) Cursor
}

// OhAuthTooTokenOrder defines the ordering of OhAuthTooToken.
type OhAuthTooTokenOrder struct {
	Direction OrderDirection            `json:"direction"`
	Field     *OhAuthTooTokenOrderField `json:"field"`
}

// DefaultOhAuthTooTokenOrder is the default ordering of OhAuthTooToken.
var DefaultOhAuthTooTokenOrder = &OhAuthTooTokenOrder{
	Direction: entgql.OrderDirectionAsc,
	Field: &OhAuthTooTokenOrderField{
		Value: func(oatt *OhAuthTooToken) (ent.Value, error) {
			return oatt.ID, nil
		},
		column: ohauthtootoken.FieldID,
		toTerm: ohauthtootoken.ByID,
		toCursor: func(oatt *OhAuthTooToken) Cursor {
			return Cursor{ID: oatt.ID}
		},
	},
}

// ToEdge converts OhAuthTooToken into OhAuthTooTokenEdge.
func (oatt *OhAuthTooToken) ToEdge(order *OhAuthTooTokenOrder) *OhAuthTooTokenEdge {
	if order == nil {
		order = DefaultOhAuthTooTokenOrder
	}
	return &OhAuthTooTokenEdge{
		Node:   oatt,
		Cursor: order.Field.toCursor(oatt),
	}
}

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

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

func (c *OrganizationConnection) build(nodes []*Organization, pager *organizationPager, 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) *Organization
	if last != nil {
		n := len(nodes) - 1
		nodeAt = func(i int) *Organization {
			return nodes[n-i]
		}
	} else {
		nodeAt = func(i int) *Organization {
			return nodes[i]
		}
	}
	c.Edges = make([]*OrganizationEdge, len(nodes))
	for i := range nodes {
		node := nodeAt(i)
		c.Edges[i] = &OrganizationEdge{
			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)
	}
}

// OrganizationPaginateOption enables pagination customization.
type OrganizationPaginateOption func(*organizationPager) error

// WithOrganizationOrder configures pagination ordering.
func WithOrganizationOrder(order *OrganizationOrder) OrganizationPaginateOption {
	if order == nil {
		order = DefaultOrganizationOrder
	}
	o := *order
	return func(pager *organizationPager) error {
		if err := o.Direction.Validate(); err != nil {
			return err
		}
		if o.Field == nil {
			o.Field = DefaultOrganizationOrder.Field
		}
		pager.order = &o
		return nil
	}
}

// WithOrganizationFilter configures pagination filter.
func WithOrganizationFilter(filter func(*OrganizationQuery) (*OrganizationQuery, error)) OrganizationPaginateOption {
	return func(pager *organizationPager) error {
		if filter == nil {
			return errors.New("OrganizationQuery filter cannot be nil")
		}
		pager.filter = filter
		return nil
	}
}

type organizationPager struct {
	reverse bool
	order   *OrganizationOrder
	filter  func(*OrganizationQuery) (*OrganizationQuery, error)
}

func newOrganizationPager(opts []OrganizationPaginateOption, reverse bool) (*organizationPager, error) {
	pager := &organizationPager{reverse: reverse}
	for _, opt := range opts {
		if err := opt(pager); err != nil {
			return nil, err
		}
	}
	if pager.order == nil {
		pager.order = DefaultOrganizationOrder
	}
	return pager, nil
}

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

func (p *organizationPager) toCursor(o *Organization) Cursor {
	return p.order.Field.toCursor(o)
}

func (p *organizationPager) applyCursors(query *OrganizationQuery, after, before *Cursor) (*OrganizationQuery, error) {
	direction := p.order.Direction
	if p.reverse {
		direction = direction.Reverse()
	}
	for _, predicate := range entgql.CursorsPredicate(after, before, DefaultOrganizationOrder.Field.column, p.order.Field.column, direction) {
		query = query.Where(predicate)
	}
	return query, nil
}

func (p *organizationPager) applyOrder(query *OrganizationQuery) *OrganizationQuery {
	direction := p.order.Direction
	if p.reverse {
		direction = direction.Reverse()
	}
	query = query.Order(p.order.Field.toTerm(direction.OrderTermOption()))
	if p.order.Field != DefaultOrganizationOrder.Field {
		query = query.Order(DefaultOrganizationOrder.Field.toTerm(direction.OrderTermOption()))
	}
	if len(query.ctx.Fields) > 0 {
		query.ctx.AppendFieldOnce(p.order.Field.column)
	}
	return query
}

func (p *organizationPager) orderExpr(query *OrganizationQuery) sql.Querier {
	direction := p.order.Direction
	if p.reverse {
		direction = direction.Reverse()
	}
	if len(query.ctx.Fields) > 0 {
		query.ctx.AppendFieldOnce(p.order.Field.column)
	}
	return sql.ExprFunc(func(b *sql.Builder) {
		b.Ident(p.order.Field.column).Pad().WriteString(string(direction))
		if p.order.Field != DefaultOrganizationOrder.Field {
			b.Comma().Ident(DefaultOrganizationOrder.Field.column).Pad().WriteString(string(direction))
		}
	})
}

// Paginate executes the query and returns a relay based cursor connection to Organization.
func (o *OrganizationQuery) Paginate(
	ctx context.Context, after *Cursor, first *int,
	before *Cursor, last *int, opts ...OrganizationPaginateOption,
) (*OrganizationConnection, error) {
	if err := validateFirstLast(first, last); err != nil {
		return nil, err
	}
	pager, err := newOrganizationPager(opts, last != nil)
	if err != nil {
		return nil, err
	}
	if o, err = pager.applyFilter(o); err != nil {
		return nil, err
	}
	conn := &OrganizationConnection{Edges: []*OrganizationEdge{}}
	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 = o.Clone().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
	}
	if o, err = pager.applyCursors(o, after, before); err != nil {
		return nil, err
	}
	if limit := paginateLimit(first, last); limit != 0 {
		o.Limit(limit)
	}
	if field := collectedField(ctx, edgesField, nodeField); field != nil {
		if err := o.collectField(ctx, graphql.GetOperationContext(ctx), *field, []string{edgesField, nodeField}); err != nil {
			return nil, err
		}
	}
	o = pager.applyOrder(o)
	nodes, err := o.All(ctx)
	if err != nil {
		return nil, err
	}
	conn.build(nodes, pager, after, first, before, last)
	return conn, nil
}

var (
	// OrganizationOrderFieldName orders Organization by name.
	OrganizationOrderFieldName = &OrganizationOrderField{
		Value: func(o *Organization) (ent.Value, error) {
			return o.Name, nil
		},
		column: organization.FieldName,
		toTerm: organization.ByName,
		toCursor: func(o *Organization) Cursor {
			return Cursor{
				ID:    o.ID,
				Value: o.Name,
			}
		},
	}
	// OrganizationOrderFieldDisplayName orders Organization by display_name.
	OrganizationOrderFieldDisplayName = &OrganizationOrderField{
		Value: func(o *Organization) (ent.Value, error) {
			return o.DisplayName, nil
		},
		column: organization.FieldDisplayName,
		toTerm: organization.ByDisplayName,
		toCursor: func(o *Organization) Cursor {
			return Cursor{
				ID:    o.ID,
				Value: o.DisplayName,
			}
		},
	}
)

// String implement fmt.Stringer interface.
func (f OrganizationOrderField) String() string {
	var str string
	switch f.column {
	case OrganizationOrderFieldName.column:
		str = "name"
	case OrganizationOrderFieldDisplayName.column:
		str = "display_name"
	}
	return str
}

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

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

// OrganizationOrderField defines the ordering field of Organization.
type OrganizationOrderField struct {
	// Value extracts the ordering value from the given Organization.
	Value    func(*Organization) (ent.Value, error)
	column   string // field or computed.
	toTerm   func(...sql.OrderTermOption) organization.OrderOption
	toCursor func(*Organization) Cursor
}

// OrganizationOrder defines the ordering of Organization.
type OrganizationOrder struct {
	Direction OrderDirection          `json:"direction"`
	Field     *OrganizationOrderField `json:"field"`
}

// DefaultOrganizationOrder is the default ordering of Organization.
var DefaultOrganizationOrder = &OrganizationOrder{
	Direction: entgql.OrderDirectionAsc,
	Field: &OrganizationOrderField{
		Value: func(o *Organization) (ent.Value, error) {
			return o.ID, nil
		},
		column: organization.FieldID,
		toTerm: organization.ByID,
		toCursor: func(o *Organization) Cursor {
			return Cursor{ID: o.ID}
		},
	},
}

// ToEdge converts Organization into OrganizationEdge.
func (o *Organization) ToEdge(order *OrganizationOrder) *OrganizationEdge {
	if order == nil {
		order = DefaultOrganizationOrder
	}
	return &OrganizationEdge{
		Node:   o,
		Cursor: order.Field.toCursor(o),
	}
}

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

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

func (c *OrganizationSettingConnection) build(nodes []*OrganizationSetting, pager *organizationsettingPager, 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) *OrganizationSetting
	if last != nil {
		n := len(nodes) - 1
		nodeAt = func(i int) *OrganizationSetting {
			return nodes[n-i]
		}
	} else {
		nodeAt = func(i int) *OrganizationSetting {
			return nodes[i]
		}
	}
	c.Edges = make([]*OrganizationSettingEdge, len(nodes))
	for i := range nodes {
		node := nodeAt(i)
		c.Edges[i] = &OrganizationSettingEdge{
			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)
	}
}

// OrganizationSettingPaginateOption enables pagination customization.
type OrganizationSettingPaginateOption func(*organizationsettingPager) error

// WithOrganizationSettingOrder configures pagination ordering.
func WithOrganizationSettingOrder(order *OrganizationSettingOrder) OrganizationSettingPaginateOption {
	if order == nil {
		order = DefaultOrganizationSettingOrder
	}
	o := *order
	return func(pager *organizationsettingPager) error {
		if err := o.Direction.Validate(); err != nil {
			return err
		}
		if o.Field == nil {
			o.Field = DefaultOrganizationSettingOrder.Field
		}
		pager.order = &o
		return nil
	}
}

// WithOrganizationSettingFilter configures pagination filter.
func WithOrganizationSettingFilter(filter func(*OrganizationSettingQuery) (*OrganizationSettingQuery, error)) OrganizationSettingPaginateOption {
	return func(pager *organizationsettingPager) error {
		if filter == nil {
			return errors.New("OrganizationSettingQuery filter cannot be nil")
		}
		pager.filter = filter
		return nil
	}
}

type organizationsettingPager struct {
	reverse bool
	order   *OrganizationSettingOrder
	filter  func(*OrganizationSettingQuery) (*OrganizationSettingQuery, error)
}

func newOrganizationSettingPager(opts []OrganizationSettingPaginateOption, reverse bool) (*organizationsettingPager, error) {
	pager := &organizationsettingPager{reverse: reverse}
	for _, opt := range opts {
		if err := opt(pager); err != nil {
			return nil, err
		}
	}
	if pager.order == nil {
		pager.order = DefaultOrganizationSettingOrder
	}
	return pager, nil
}

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

func (p *organizationsettingPager) toCursor(os *OrganizationSetting) Cursor {
	return p.order.Field.toCursor(os)
}

func (p *organizationsettingPager) applyCursors(query *OrganizationSettingQuery, after, before *Cursor) (*OrganizationSettingQuery, error) {
	direction := p.order.Direction
	if p.reverse {
		direction = direction.Reverse()
	}
	for _, predicate := range entgql.CursorsPredicate(after, before, DefaultOrganizationSettingOrder.Field.column, p.order.Field.column, direction) {
		query = query.Where(predicate)
	}
	return query, nil
}

func (p *organizationsettingPager) applyOrder(query *OrganizationSettingQuery) *OrganizationSettingQuery {
	direction := p.order.Direction
	if p.reverse {
		direction = direction.Reverse()
	}
	query = query.Order(p.order.Field.toTerm(direction.OrderTermOption()))
	if p.order.Field != DefaultOrganizationSettingOrder.Field {
		query = query.Order(DefaultOrganizationSettingOrder.Field.toTerm(direction.OrderTermOption()))
	}
	if len(query.ctx.Fields) > 0 {
		query.ctx.AppendFieldOnce(p.order.Field.column)
	}
	return query
}

func (p *organizationsettingPager) orderExpr(query *OrganizationSettingQuery) sql.Querier {
	direction := p.order.Direction
	if p.reverse {
		direction = direction.Reverse()
	}
	if len(query.ctx.Fields) > 0 {
		query.ctx.AppendFieldOnce(p.order.Field.column)
	}
	return sql.ExprFunc(func(b *sql.Builder) {
		b.Ident(p.order.Field.column).Pad().WriteString(string(direction))
		if p.order.Field != DefaultOrganizationSettingOrder.Field {
			b.Comma().Ident(DefaultOrganizationSettingOrder.Field.column).Pad().WriteString(string(direction))
		}
	})
}

// Paginate executes the query and returns a relay based cursor connection to OrganizationSetting.
func (os *OrganizationSettingQuery) Paginate(
	ctx context.Context, after *Cursor, first *int,
	before *Cursor, last *int, opts ...OrganizationSettingPaginateOption,
) (*OrganizationSettingConnection, error) {
	if err := validateFirstLast(first, last); err != nil {
		return nil, err
	}
	pager, err := newOrganizationSettingPager(opts, last != nil)
	if err != nil {
		return nil, err
	}
	if os, err = pager.applyFilter(os); err != nil {
		return nil, err
	}
	conn := &OrganizationSettingConnection{Edges: []*OrganizationSettingEdge{}}
	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 = os.Clone().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
	}
	if os, err = pager.applyCursors(os, after, before); err != nil {
		return nil, err
	}
	if limit := paginateLimit(first, last); limit != 0 {
		os.Limit(limit)
	}
	if field := collectedField(ctx, edgesField, nodeField); field != nil {
		if err := os.collectField(ctx, graphql.GetOperationContext(ctx), *field, []string{edgesField, nodeField}); err != nil {
			return nil, err
		}
	}
	os = pager.applyOrder(os)
	nodes, err := os.All(ctx)
	if err != nil {
		return nil, err
	}
	conn.build(nodes, pager, after, first, before, last)
	return conn, nil
}

// OrganizationSettingOrderField defines the ordering field of OrganizationSetting.
type OrganizationSettingOrderField struct {
	// Value extracts the ordering value from the given OrganizationSetting.
	Value    func(*OrganizationSetting) (ent.Value, error)
	column   string // field or computed.
	toTerm   func(...sql.OrderTermOption) organizationsetting.OrderOption
	toCursor func(*OrganizationSetting) Cursor
}

// OrganizationSettingOrder defines the ordering of OrganizationSetting.
type OrganizationSettingOrder struct {
	Direction OrderDirection                 `json:"direction"`
	Field     *OrganizationSettingOrderField `json:"field"`
}

// DefaultOrganizationSettingOrder is the default ordering of OrganizationSetting.
var DefaultOrganizationSettingOrder = &OrganizationSettingOrder{
	Direction: entgql.OrderDirectionAsc,
	Field: &OrganizationSettingOrderField{
		Value: func(os *OrganizationSetting) (ent.Value, error) {
			return os.ID, nil
		},
		column: organizationsetting.FieldID,
		toTerm: organizationsetting.ByID,
		toCursor: func(os *OrganizationSetting) Cursor {
			return Cursor{ID: os.ID}
		},
	},
}

// ToEdge converts OrganizationSetting into OrganizationSettingEdge.
func (os *OrganizationSetting) ToEdge(order *OrganizationSettingOrder) *OrganizationSettingEdge {
	if order == nil {
		order = DefaultOrganizationSettingOrder
	}
	return &OrganizationSettingEdge{
		Node:   os,
		Cursor: order.Field.toCursor(os),
	}
}

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

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

func (c *PersonalAccessTokenConnection) build(nodes []*PersonalAccessToken, pager *personalaccesstokenPager, 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) *PersonalAccessToken
	if last != nil {
		n := len(nodes) - 1
		nodeAt = func(i int) *PersonalAccessToken {
			return nodes[n-i]
		}
	} else {
		nodeAt = func(i int) *PersonalAccessToken {
			return nodes[i]
		}
	}
	c.Edges = make([]*PersonalAccessTokenEdge, len(nodes))
	for i := range nodes {
		node := nodeAt(i)
		c.Edges[i] = &PersonalAccessTokenEdge{
			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)
	}
}

// PersonalAccessTokenPaginateOption enables pagination customization.
type PersonalAccessTokenPaginateOption func(*personalaccesstokenPager) error

// WithPersonalAccessTokenOrder configures pagination ordering.
func WithPersonalAccessTokenOrder(order *PersonalAccessTokenOrder) PersonalAccessTokenPaginateOption {
	if order == nil {
		order = DefaultPersonalAccessTokenOrder
	}
	o := *order
	return func(pager *personalaccesstokenPager) error {
		if err := o.Direction.Validate(); err != nil {
			return err
		}
		if o.Field == nil {
			o.Field = DefaultPersonalAccessTokenOrder.Field
		}
		pager.order = &o
		return nil
	}
}

// WithPersonalAccessTokenFilter configures pagination filter.
func WithPersonalAccessTokenFilter(filter func(*PersonalAccessTokenQuery) (*PersonalAccessTokenQuery, error)) PersonalAccessTokenPaginateOption {
	return func(pager *personalaccesstokenPager) error {
		if filter == nil {
			return errors.New("PersonalAccessTokenQuery filter cannot be nil")
		}
		pager.filter = filter
		return nil
	}
}

type personalaccesstokenPager struct {
	reverse bool
	order   *PersonalAccessTokenOrder
	filter  func(*PersonalAccessTokenQuery) (*PersonalAccessTokenQuery, error)
}

func newPersonalAccessTokenPager(opts []PersonalAccessTokenPaginateOption, reverse bool) (*personalaccesstokenPager, error) {
	pager := &personalaccesstokenPager{reverse: reverse}
	for _, opt := range opts {
		if err := opt(pager); err != nil {
			return nil, err
		}
	}
	if pager.order == nil {
		pager.order = DefaultPersonalAccessTokenOrder
	}
	return pager, nil
}

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

func (p *personalaccesstokenPager) toCursor(pat *PersonalAccessToken) Cursor {
	return p.order.Field.toCursor(pat)
}

func (p *personalaccesstokenPager) applyCursors(query *PersonalAccessTokenQuery, after, before *Cursor) (*PersonalAccessTokenQuery, error) {
	direction := p.order.Direction
	if p.reverse {
		direction = direction.Reverse()
	}
	for _, predicate := range entgql.CursorsPredicate(after, before, DefaultPersonalAccessTokenOrder.Field.column, p.order.Field.column, direction) {
		query = query.Where(predicate)
	}
	return query, nil
}

func (p *personalaccesstokenPager) applyOrder(query *PersonalAccessTokenQuery) *PersonalAccessTokenQuery {
	direction := p.order.Direction
	if p.reverse {
		direction = direction.Reverse()
	}
	query = query.Order(p.order.Field.toTerm(direction.OrderTermOption()))
	if p.order.Field != DefaultPersonalAccessTokenOrder.Field {
		query = query.Order(DefaultPersonalAccessTokenOrder.Field.toTerm(direction.OrderTermOption()))
	}
	if len(query.ctx.Fields) > 0 {
		query.ctx.AppendFieldOnce(p.order.Field.column)
	}
	return query
}

func (p *personalaccesstokenPager) orderExpr(query *PersonalAccessTokenQuery) sql.Querier {
	direction := p.order.Direction
	if p.reverse {
		direction = direction.Reverse()
	}
	if len(query.ctx.Fields) > 0 {
		query.ctx.AppendFieldOnce(p.order.Field.column)
	}
	return sql.ExprFunc(func(b *sql.Builder) {
		b.Ident(p.order.Field.column).Pad().WriteString(string(direction))
		if p.order.Field != DefaultPersonalAccessTokenOrder.Field {
			b.Comma().Ident(DefaultPersonalAccessTokenOrder.Field.column).Pad().WriteString(string(direction))
		}
	})
}

// Paginate executes the query and returns a relay based cursor connection to PersonalAccessToken.
func (pat *PersonalAccessTokenQuery) Paginate(
	ctx context.Context, after *Cursor, first *int,
	before *Cursor, last *int, opts ...PersonalAccessTokenPaginateOption,
) (*PersonalAccessTokenConnection, error) {
	if err := validateFirstLast(first, last); err != nil {
		return nil, err
	}
	pager, err := newPersonalAccessTokenPager(opts, last != nil)
	if err != nil {
		return nil, err
	}
	if pat, err = pager.applyFilter(pat); err != nil {
		return nil, err
	}
	conn := &PersonalAccessTokenConnection{Edges: []*PersonalAccessTokenEdge{}}
	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 = pat.Clone().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
	}
	if pat, err = pager.applyCursors(pat, after, before); err != nil {
		return nil, err
	}
	if limit := paginateLimit(first, last); limit != 0 {
		pat.Limit(limit)
	}
	if field := collectedField(ctx, edgesField, nodeField); field != nil {
		if err := pat.collectField(ctx, graphql.GetOperationContext(ctx), *field, []string{edgesField, nodeField}); err != nil {
			return nil, err
		}
	}
	pat = pager.applyOrder(pat)
	nodes, err := pat.All(ctx)
	if err != nil {
		return nil, err
	}
	conn.build(nodes, pager, after, first, before, last)
	return conn, nil
}

// PersonalAccessTokenOrderField defines the ordering field of PersonalAccessToken.
type PersonalAccessTokenOrderField struct {
	// Value extracts the ordering value from the given PersonalAccessToken.
	Value    func(*PersonalAccessToken) (ent.Value, error)
	column   string // field or computed.
	toTerm   func(...sql.OrderTermOption) personalaccesstoken.OrderOption
	toCursor func(*PersonalAccessToken) Cursor
}

// PersonalAccessTokenOrder defines the ordering of PersonalAccessToken.
type PersonalAccessTokenOrder struct {
	Direction OrderDirection                 `json:"direction"`
	Field     *PersonalAccessTokenOrderField `json:"field"`
}

// DefaultPersonalAccessTokenOrder is the default ordering of PersonalAccessToken.
var DefaultPersonalAccessTokenOrder = &PersonalAccessTokenOrder{
	Direction: entgql.OrderDirectionAsc,
	Field: &PersonalAccessTokenOrderField{
		Value: func(pat *PersonalAccessToken) (ent.Value, error) {
			return pat.ID, nil
		},
		column: personalaccesstoken.FieldID,
		toTerm: personalaccesstoken.ByID,
		toCursor: func(pat *PersonalAccessToken) Cursor {
			return Cursor{ID: pat.ID}
		},
	},
}

// ToEdge converts PersonalAccessToken into PersonalAccessTokenEdge.
func (pat *PersonalAccessToken) ToEdge(order *PersonalAccessTokenOrder) *PersonalAccessTokenEdge {
	if order == nil {
		order = DefaultPersonalAccessTokenOrder
	}
	return &PersonalAccessTokenEdge{
		Node:   pat,
		Cursor: order.Field.toCursor(pat),
	}
}

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

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

func (c *SessionConnection) build(nodes []*Session, pager *sessionPager, 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) *Session
	if last != nil {
		n := len(nodes) - 1
		nodeAt = func(i int) *Session {
			return nodes[n-i]
		}
	} else {
		nodeAt = func(i int) *Session {
			return nodes[i]
		}
	}
	c.Edges = make([]*SessionEdge, len(nodes))
	for i := range nodes {
		node := nodeAt(i)
		c.Edges[i] = &SessionEdge{
			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)
	}
}

// SessionPaginateOption enables pagination customization.
type SessionPaginateOption func(*sessionPager) error

// WithSessionOrder configures pagination ordering.
func WithSessionOrder(order *SessionOrder) SessionPaginateOption {
	if order == nil {
		order = DefaultSessionOrder
	}
	o := *order
	return func(pager *sessionPager) error {
		if err := o.Direction.Validate(); err != nil {
			return err
		}
		if o.Field == nil {
			o.Field = DefaultSessionOrder.Field
		}
		pager.order = &o
		return nil
	}
}

// WithSessionFilter configures pagination filter.
func WithSessionFilter(filter func(*SessionQuery) (*SessionQuery, error)) SessionPaginateOption {
	return func(pager *sessionPager) error {
		if filter == nil {
			return errors.New("SessionQuery filter cannot be nil")
		}
		pager.filter = filter
		return nil
	}
}

type sessionPager struct {
	reverse bool
	order   *SessionOrder
	filter  func(*SessionQuery) (*SessionQuery, error)
}

func newSessionPager(opts []SessionPaginateOption, reverse bool) (*sessionPager, error) {
	pager := &sessionPager{reverse: reverse}
	for _, opt := range opts {
		if err := opt(pager); err != nil {
			return nil, err
		}
	}
	if pager.order == nil {
		pager.order = DefaultSessionOrder
	}
	return pager, nil
}

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

func (p *sessionPager) toCursor(s *Session) Cursor {
	return p.order.Field.toCursor(s)
}

func (p *sessionPager) applyCursors(query *SessionQuery, after, before *Cursor) (*SessionQuery, error) {
	direction := p.order.Direction
	if p.reverse {
		direction = direction.Reverse()
	}
	for _, predicate := range entgql.CursorsPredicate(after, before, DefaultSessionOrder.Field.column, p.order.Field.column, direction) {
		query = query.Where(predicate)
	}
	return query, nil
}

func (p *sessionPager) applyOrder(query *SessionQuery) *SessionQuery {
	direction := p.order.Direction
	if p.reverse {
		direction = direction.Reverse()
	}
	query = query.Order(p.order.Field.toTerm(direction.OrderTermOption()))
	if p.order.Field != DefaultSessionOrder.Field {
		query = query.Order(DefaultSessionOrder.Field.toTerm(direction.OrderTermOption()))
	}
	if len(query.ctx.Fields) > 0 {
		query.ctx.AppendFieldOnce(p.order.Field.column)
	}
	return query
}

func (p *sessionPager) orderExpr(query *SessionQuery) sql.Querier {
	direction := p.order.Direction
	if p.reverse {
		direction = direction.Reverse()
	}
	if len(query.ctx.Fields) > 0 {
		query.ctx.AppendFieldOnce(p.order.Field.column)
	}
	return sql.ExprFunc(func(b *sql.Builder) {
		b.Ident(p.order.Field.column).Pad().WriteString(string(direction))
		if p.order.Field != DefaultSessionOrder.Field {
			b.Comma().Ident(DefaultSessionOrder.Field.column).Pad().WriteString(string(direction))
		}
	})
}

// Paginate executes the query and returns a relay based cursor connection to Session.
func (s *SessionQuery) Paginate(
	ctx context.Context, after *Cursor, first *int,
	before *Cursor, last *int, opts ...SessionPaginateOption,
) (*SessionConnection, error) {
	if err := validateFirstLast(first, last); err != nil {
		return nil, err
	}
	pager, err := newSessionPager(opts, last != nil)
	if err != nil {
		return nil, err
	}
	if s, err = pager.applyFilter(s); err != nil {
		return nil, err
	}
	conn := &SessionConnection{Edges: []*SessionEdge{}}
	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.Clone().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
	}
	if s, err = pager.applyCursors(s, after, before); err != nil {
		return nil, err
	}
	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
		}
	}
	s = pager.applyOrder(s)
	nodes, err := s.All(ctx)
	if err != nil {
		return nil, err
	}
	conn.build(nodes, pager, after, first, before, last)
	return conn, nil
}

// SessionOrderField defines the ordering field of Session.
type SessionOrderField struct {
	// Value extracts the ordering value from the given Session.
	Value    func(*Session) (ent.Value, error)
	column   string // field or computed.
	toTerm   func(...sql.OrderTermOption) session.OrderOption
	toCursor func(*Session) Cursor
}

// SessionOrder defines the ordering of Session.
type SessionOrder struct {
	Direction OrderDirection     `json:"direction"`
	Field     *SessionOrderField `json:"field"`
}

// DefaultSessionOrder is the default ordering of Session.
var DefaultSessionOrder = &SessionOrder{
	Direction: entgql.OrderDirectionAsc,
	Field: &SessionOrderField{
		Value: func(s *Session) (ent.Value, error) {
			return s.ID, nil
		},
		column: session.FieldID,
		toTerm: session.ByID,
		toCursor: func(s *Session) Cursor {
			return Cursor{ID: s.ID}
		},
	},
}

// ToEdge converts Session into SessionEdge.
func (s *Session) ToEdge(order *SessionOrder) *SessionEdge {
	if order == nil {
		order = DefaultSessionOrder
	}
	return &SessionEdge{
		Node:   s,
		Cursor: order.Field.toCursor(s),
	}
}

// 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 {
	reverse bool
	order   *UserOrder
	filter  func(*UserQuery) (*UserQuery, error)
}

func newUserPager(opts []UserPaginateOption, reverse bool) (*userPager, error) {
	pager := &userPager{reverse: reverse}
	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, error) {
	direction := p.order.Direction
	if p.reverse {
		direction = direction.Reverse()
	}
	for _, predicate := range entgql.CursorsPredicate(after, before, DefaultUserOrder.Field.column, p.order.Field.column, direction) {
		query = query.Where(predicate)
	}
	return query, nil
}

func (p *userPager) applyOrder(query *UserQuery) *UserQuery {
	direction := p.order.Direction
	if p.reverse {
		direction = direction.Reverse()
	}
	query = query.Order(p.order.Field.toTerm(direction.OrderTermOption()))
	if p.order.Field != DefaultUserOrder.Field {
		query = query.Order(DefaultUserOrder.Field.toTerm(direction.OrderTermOption()))
	}
	if len(query.ctx.Fields) > 0 {
		query.ctx.AppendFieldOnce(p.order.Field.column)
	}
	return query
}

func (p *userPager) orderExpr(query *UserQuery) sql.Querier {
	direction := p.order.Direction
	if p.reverse {
		direction = direction.Reverse()
	}
	if len(query.ctx.Fields) > 0 {
		query.ctx.AppendFieldOnce(p.order.Field.column)
	}
	return sql.ExprFunc(func(b *sql.Builder) {
		b.Ident(p.order.Field.column).Pad().WriteString(string(direction))
		if p.order.Field != DefaultUserOrder.Field {
			b.Comma().Ident(DefaultUserOrder.Field.column).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, last != nil)
	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.Clone().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
	}
	if u, err = pager.applyCursors(u, after, before); err != nil {
		return nil, err
	}
	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
		}
	}
	u = pager.applyOrder(u)
	nodes, err := u.All(ctx)
	if err != nil {
		return nil, err
	}
	conn.build(nodes, pager, after, first, before, last)
	return conn, nil
}

var (
	// UserOrderFieldFirstName orders User by first_name.
	UserOrderFieldFirstName = &UserOrderField{
		Value: func(u *User) (ent.Value, error) {
			return u.FirstName, nil
		},
		column: user.FieldFirstName,
		toTerm: user.ByFirstName,
		toCursor: func(u *User) Cursor {
			return Cursor{
				ID:    u.ID,
				Value: u.FirstName,
			}
		},
	}
	// UserOrderFieldLastName orders User by last_name.
	UserOrderFieldLastName = &UserOrderField{
		Value: func(u *User) (ent.Value, error) {
			return u.LastName, nil
		},
		column: user.FieldLastName,
		toTerm: user.ByLastName,
		toCursor: func(u *User) Cursor {
			return Cursor{
				ID:    u.ID,
				Value: u.LastName,
			}
		},
	}
	// UserOrderFieldDisplayName orders User by display_name.
	UserOrderFieldDisplayName = &UserOrderField{
		Value: func(u *User) (ent.Value, error) {
			return u.DisplayName, nil
		},
		column: user.FieldDisplayName,
		toTerm: user.ByDisplayName,
		toCursor: func(u *User) Cursor {
			return Cursor{
				ID:    u.ID,
				Value: u.DisplayName,
			}
		},
	}
)

// String implement fmt.Stringer interface.
func (f UserOrderField) String() string {
	var str string
	switch f.column {
	case UserOrderFieldFirstName.column:
		str = "first_name"
	case UserOrderFieldLastName.column:
		str = "last_name"
	case UserOrderFieldDisplayName.column:
		str = "display_name"
	}
	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 "first_name":
		*f = *UserOrderFieldFirstName
	case "last_name":
		*f = *UserOrderFieldLastName
	case "display_name":
		*f = *UserOrderFieldDisplayName
	default:
		return fmt.Errorf("%s is not a valid UserOrderField", str)
	}
	return nil
}

// UserOrderField defines the ordering field of User.
type UserOrderField struct {
	// Value extracts the ordering value from the given User.
	Value    func(*User) (ent.Value, error)
	column   string // field or computed.
	toTerm   func(...sql.OrderTermOption) user.OrderOption
	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: entgql.OrderDirectionAsc,
	Field: &UserOrderField{
		Value: func(u *User) (ent.Value, error) {
			return u.ID, nil
		},
		column: user.FieldID,
		toTerm: user.ByID,
		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),
	}
}

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

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

func (c *UserSettingConnection) build(nodes []*UserSetting, pager *usersettingPager, 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) *UserSetting
	if last != nil {
		n := len(nodes) - 1
		nodeAt = func(i int) *UserSetting {
			return nodes[n-i]
		}
	} else {
		nodeAt = func(i int) *UserSetting {
			return nodes[i]
		}
	}
	c.Edges = make([]*UserSettingEdge, len(nodes))
	for i := range nodes {
		node := nodeAt(i)
		c.Edges[i] = &UserSettingEdge{
			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)
	}
}

// UserSettingPaginateOption enables pagination customization.
type UserSettingPaginateOption func(*usersettingPager) error

// WithUserSettingOrder configures pagination ordering.
func WithUserSettingOrder(order *UserSettingOrder) UserSettingPaginateOption {
	if order == nil {
		order = DefaultUserSettingOrder
	}
	o := *order
	return func(pager *usersettingPager) error {
		if err := o.Direction.Validate(); err != nil {
			return err
		}
		if o.Field == nil {
			o.Field = DefaultUserSettingOrder.Field
		}
		pager.order = &o
		return nil
	}
}

// WithUserSettingFilter configures pagination filter.
func WithUserSettingFilter(filter func(*UserSettingQuery) (*UserSettingQuery, error)) UserSettingPaginateOption {
	return func(pager *usersettingPager) error {
		if filter == nil {
			return errors.New("UserSettingQuery filter cannot be nil")
		}
		pager.filter = filter
		return nil
	}
}

type usersettingPager struct {
	reverse bool
	order   *UserSettingOrder
	filter  func(*UserSettingQuery) (*UserSettingQuery, error)
}

func newUserSettingPager(opts []UserSettingPaginateOption, reverse bool) (*usersettingPager, error) {
	pager := &usersettingPager{reverse: reverse}
	for _, opt := range opts {
		if err := opt(pager); err != nil {
			return nil, err
		}
	}
	if pager.order == nil {
		pager.order = DefaultUserSettingOrder
	}
	return pager, nil
}

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

func (p *usersettingPager) toCursor(us *UserSetting) Cursor {
	return p.order.Field.toCursor(us)
}

func (p *usersettingPager) applyCursors(query *UserSettingQuery, after, before *Cursor) (*UserSettingQuery, error) {
	direction := p.order.Direction
	if p.reverse {
		direction = direction.Reverse()
	}
	for _, predicate := range entgql.CursorsPredicate(after, before, DefaultUserSettingOrder.Field.column, p.order.Field.column, direction) {
		query = query.Where(predicate)
	}
	return query, nil
}

func (p *usersettingPager) applyOrder(query *UserSettingQuery) *UserSettingQuery {
	direction := p.order.Direction
	if p.reverse {
		direction = direction.Reverse()
	}
	query = query.Order(p.order.Field.toTerm(direction.OrderTermOption()))
	if p.order.Field != DefaultUserSettingOrder.Field {
		query = query.Order(DefaultUserSettingOrder.Field.toTerm(direction.OrderTermOption()))
	}
	if len(query.ctx.Fields) > 0 {
		query.ctx.AppendFieldOnce(p.order.Field.column)
	}
	return query
}

func (p *usersettingPager) orderExpr(query *UserSettingQuery) sql.Querier {
	direction := p.order.Direction
	if p.reverse {
		direction = direction.Reverse()
	}
	if len(query.ctx.Fields) > 0 {
		query.ctx.AppendFieldOnce(p.order.Field.column)
	}
	return sql.ExprFunc(func(b *sql.Builder) {
		b.Ident(p.order.Field.column).Pad().WriteString(string(direction))
		if p.order.Field != DefaultUserSettingOrder.Field {
			b.Comma().Ident(DefaultUserSettingOrder.Field.column).Pad().WriteString(string(direction))
		}
	})
}

// Paginate executes the query and returns a relay based cursor connection to UserSetting.
func (us *UserSettingQuery) Paginate(
	ctx context.Context, after *Cursor, first *int,
	before *Cursor, last *int, opts ...UserSettingPaginateOption,
) (*UserSettingConnection, error) {
	if err := validateFirstLast(first, last); err != nil {
		return nil, err
	}
	pager, err := newUserSettingPager(opts, last != nil)
	if err != nil {
		return nil, err
	}
	if us, err = pager.applyFilter(us); err != nil {
		return nil, err
	}
	conn := &UserSettingConnection{Edges: []*UserSettingEdge{}}
	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 = us.Clone().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
	}
	if us, err = pager.applyCursors(us, after, before); err != nil {
		return nil, err
	}
	if limit := paginateLimit(first, last); limit != 0 {
		us.Limit(limit)
	}
	if field := collectedField(ctx, edgesField, nodeField); field != nil {
		if err := us.collectField(ctx, graphql.GetOperationContext(ctx), *field, []string{edgesField, nodeField}); err != nil {
			return nil, err
		}
	}
	us = pager.applyOrder(us)
	nodes, err := us.All(ctx)
	if err != nil {
		return nil, err
	}
	conn.build(nodes, pager, after, first, before, last)
	return conn, nil
}

// UserSettingOrderField defines the ordering field of UserSetting.
type UserSettingOrderField struct {
	// Value extracts the ordering value from the given UserSetting.
	Value    func(*UserSetting) (ent.Value, error)
	column   string // field or computed.
	toTerm   func(...sql.OrderTermOption) usersetting.OrderOption
	toCursor func(*UserSetting) Cursor
}

// UserSettingOrder defines the ordering of UserSetting.
type UserSettingOrder struct {
	Direction OrderDirection         `json:"direction"`
	Field     *UserSettingOrderField `json:"field"`
}

// DefaultUserSettingOrder is the default ordering of UserSetting.
var DefaultUserSettingOrder = &UserSettingOrder{
	Direction: entgql.OrderDirectionAsc,
	Field: &UserSettingOrderField{
		Value: func(us *UserSetting) (ent.Value, error) {
			return us.ID, nil
		},
		column: usersetting.FieldID,
		toTerm: usersetting.ByID,
		toCursor: func(us *UserSetting) Cursor {
			return Cursor{ID: us.ID}
		},
	},
}

// ToEdge converts UserSetting into UserSettingEdge.
func (us *UserSetting) ToEdge(order *UserSettingOrder) *UserSettingEdge {
	if order == nil {
		order = DefaultUserSettingOrder
	}
	return &UserSettingEdge{
		Node:   us,
		Cursor: order.Field.toCursor(us),
	}
}