gql_collection.go

// Code generated by ent, DO NOT EDIT.

package ent

import (
	"context"
	"database/sql/driver"
	"fmt"

	"entgo.io/ent/dialect/sql"
	"github.com/99designs/gqlgen/graphql"
	"github.com/chenningg/hermitboard-api/ent/account"
	"github.com/chenningg/hermitboard-api/ent/asset"
	"github.com/chenningg/hermitboard-api/ent/authrole"
	"github.com/chenningg/hermitboard-api/ent/blockchain"
	"github.com/chenningg/hermitboard-api/ent/connection"
	"github.com/chenningg/hermitboard-api/ent/cryptocurrency"
	"github.com/chenningg/hermitboard-api/ent/exchange"
	"github.com/chenningg/hermitboard-api/ent/portfolio"
	"github.com/chenningg/hermitboard-api/ent/sourcetype"
	"github.com/chenningg/hermitboard-api/ent/staffaccount"
	"github.com/chenningg/hermitboard-api/pulid"
)

// CollectFields tells the query-builder to eagerly load connected nodes by resolver context.
func (a *AccountQuery) CollectFields(ctx context.Context, satisfies ...string) (*AccountQuery, error) {
	fc := graphql.GetFieldContext(ctx)
	if fc == nil {
		return a, nil
	}
	if err := a.collectField(ctx, graphql.GetOperationContext(ctx), fc.Field, nil, satisfies...); err != nil {
		return nil, err
	}
	return a, nil
}

func (a *AccountQuery) collectField(ctx context.Context, op *graphql.OperationContext, field graphql.CollectedField, path []string, satisfies ...string) error {
	path = append([]string(nil), path...)
	for _, field := range graphql.CollectFields(op, field.Selections, satisfies) {
		switch field.Name {
		case "friends":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = &AccountQuery{config: a.config}
			)
			args := newAccountPaginateArgs(fieldArgs(ctx, new(AccountWhereInput), path...))
			if err := validateFirstLast(args.first, args.last); err != nil {
				return fmt.Errorf("validate first and last in path %q: %w", path, err)
			}
			pager, err := newAccountPager(args.opts)
			if err != nil {
				return fmt.Errorf("create new pager in path %q: %w", path, err)
			}
			if query, err = pager.applyFilter(query); err != nil {
				return err
			}
			ignoredEdges := !hasCollectedField(ctx, append(path, edgesField)...)
			if hasCollectedField(ctx, append(path, totalCountField)...) || hasCollectedField(ctx, append(path, pageInfoField)...) {
				hasPagination := args.after != nil || args.first != nil || args.before != nil || args.last != nil
				if hasPagination || ignoredEdges {
					query := query.Clone()
					a.loadTotal = append(a.loadTotal, func(ctx context.Context, nodes []*Account) error {
						ids := make([]driver.Value, len(nodes))
						for i := range nodes {
							ids[i] = nodes[i].ID
						}
						var v []struct {
							NodeID pulid.PULID `sql:"account_id"`
							Count  int         `sql:"count"`
						}
						query.Where(func(s *sql.Selector) {
							joinT := sql.Table(account.FriendsTable)
							s.Join(joinT).On(s.C(account.FieldID), joinT.C(account.FriendsPrimaryKey[1]))
							s.Where(sql.InValues(joinT.C(account.FriendsPrimaryKey[0]), ids...))
							s.Select(joinT.C(account.FriendsPrimaryKey[0]), sql.Count("*"))
							s.GroupBy(joinT.C(account.FriendsPrimaryKey[0]))
						})
						if err := query.Select().Scan(ctx, &v); err != nil {
							return err
						}
						m := make(map[pulid.PULID]int, len(v))
						for i := range v {
							m[v[i].NodeID] = v[i].Count
						}
						for i := range nodes {
							n := m[nodes[i].ID]
							if nodes[i].Edges.totalCount[0] == nil {
								nodes[i].Edges.totalCount[0] = make(map[string]int)
							}
							nodes[i].Edges.totalCount[0][alias] = n
						}
						return nil
					})
				} else {
					a.loadTotal = append(a.loadTotal, func(_ context.Context, nodes []*Account) error {
						for i := range nodes {
							n := len(nodes[i].Edges.Friends)
							if nodes[i].Edges.totalCount[0] == nil {
								nodes[i].Edges.totalCount[0] = make(map[string]int)
							}
							nodes[i].Edges.totalCount[0][alias] = n
						}
						return nil
					})
				}
			}
			if ignoredEdges || (args.first != nil && *args.first == 0) || (args.last != nil && *args.last == 0) {
				continue
			}

			query = pager.applyCursors(query, args.after, args.before)
			if limit := paginateLimit(args.first, args.last); limit > 0 {
				modify := limitRows(account.FriendsPrimaryKey[0], limit, pager.orderExpr(args.last != nil))
				query.modifiers = append(query.modifiers, modify)
			} else {
				query = pager.applyOrder(query, args.last != nil)
			}
			path = append(path, edgesField, nodeField)
			if field := collectedField(ctx, path...); field != nil {
				if err := query.collectField(ctx, op, *field, path, satisfies...); err != nil {
					return err
				}
			}
			a.WithNamedFriends(alias, func(wq *AccountQuery) {
				*wq = *query
			})
		case "authRoles":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = &AuthRoleQuery{config: a.config}
			)
			args := newAuthRolePaginateArgs(fieldArgs(ctx, new(AuthRoleWhereInput), path...))
			if err := validateFirstLast(args.first, args.last); err != nil {
				return fmt.Errorf("validate first and last in path %q: %w", path, err)
			}
			pager, err := newAuthRolePager(args.opts)
			if err != nil {
				return fmt.Errorf("create new pager in path %q: %w", path, err)
			}
			if query, err = pager.applyFilter(query); err != nil {
				return err
			}
			ignoredEdges := !hasCollectedField(ctx, append(path, edgesField)...)
			if hasCollectedField(ctx, append(path, totalCountField)...) || hasCollectedField(ctx, append(path, pageInfoField)...) {
				hasPagination := args.after != nil || args.first != nil || args.before != nil || args.last != nil
				if hasPagination || ignoredEdges {
					query := query.Clone()
					a.loadTotal = append(a.loadTotal, func(ctx context.Context, nodes []*Account) error {
						ids := make([]driver.Value, len(nodes))
						for i := range nodes {
							ids[i] = nodes[i].ID
						}
						var v []struct {
							NodeID pulid.PULID `sql:"account_id"`
							Count  int         `sql:"count"`
						}
						query.Where(func(s *sql.Selector) {
							joinT := sql.Table(account.AuthRolesTable)
							s.Join(joinT).On(s.C(authrole.FieldID), joinT.C(account.AuthRolesPrimaryKey[1]))
							s.Where(sql.InValues(joinT.C(account.AuthRolesPrimaryKey[0]), ids...))
							s.Select(joinT.C(account.AuthRolesPrimaryKey[0]), sql.Count("*"))
							s.GroupBy(joinT.C(account.AuthRolesPrimaryKey[0]))
						})
						if err := query.Select().Scan(ctx, &v); err != nil {
							return err
						}
						m := make(map[pulid.PULID]int, len(v))
						for i := range v {
							m[v[i].NodeID] = v[i].Count
						}
						for i := range nodes {
							n := m[nodes[i].ID]
							if nodes[i].Edges.totalCount[1] == nil {
								nodes[i].Edges.totalCount[1] = make(map[string]int)
							}
							nodes[i].Edges.totalCount[1][alias] = n
						}
						return nil
					})
				} else {
					a.loadTotal = append(a.loadTotal, func(_ context.Context, nodes []*Account) error {
						for i := range nodes {
							n := len(nodes[i].Edges.AuthRoles)
							if nodes[i].Edges.totalCount[1] == nil {
								nodes[i].Edges.totalCount[1] = make(map[string]int)
							}
							nodes[i].Edges.totalCount[1][alias] = n
						}
						return nil
					})
				}
			}
			if ignoredEdges || (args.first != nil && *args.first == 0) || (args.last != nil && *args.last == 0) {
				continue
			}

			query = pager.applyCursors(query, args.after, args.before)
			if limit := paginateLimit(args.first, args.last); limit > 0 {
				modify := limitRows(account.AuthRolesPrimaryKey[0], limit, pager.orderExpr(args.last != nil))
				query.modifiers = append(query.modifiers, modify)
			} else {
				query = pager.applyOrder(query, args.last != nil)
			}
			path = append(path, edgesField, nodeField)
			if field := collectedField(ctx, path...); field != nil {
				if err := query.collectField(ctx, op, *field, path, satisfies...); err != nil {
					return err
				}
			}
			a.WithNamedAuthRoles(alias, func(wq *AuthRoleQuery) {
				*wq = *query
			})
		case "portfolios":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = &PortfolioQuery{config: a.config}
			)
			args := newPortfolioPaginateArgs(fieldArgs(ctx, new(PortfolioWhereInput), path...))
			if err := validateFirstLast(args.first, args.last); err != nil {
				return fmt.Errorf("validate first and last in path %q: %w", path, err)
			}
			pager, err := newPortfolioPager(args.opts)
			if err != nil {
				return fmt.Errorf("create new pager in path %q: %w", path, err)
			}
			if query, err = pager.applyFilter(query); err != nil {
				return err
			}
			ignoredEdges := !hasCollectedField(ctx, append(path, edgesField)...)
			if hasCollectedField(ctx, append(path, totalCountField)...) || hasCollectedField(ctx, append(path, pageInfoField)...) {
				hasPagination := args.after != nil || args.first != nil || args.before != nil || args.last != nil
				if hasPagination || ignoredEdges {
					query := query.Clone()
					a.loadTotal = append(a.loadTotal, func(ctx context.Context, nodes []*Account) error {
						ids := make([]driver.Value, len(nodes))
						for i := range nodes {
							ids[i] = nodes[i].ID
						}
						var v []struct {
							NodeID pulid.PULID `sql:"account_id"`
							Count  int         `sql:"count"`
						}
						query.Where(func(s *sql.Selector) {
							s.Where(sql.InValues(account.PortfoliosColumn, ids...))
						})
						if err := query.GroupBy(account.PortfoliosColumn).Aggregate(Count()).Scan(ctx, &v); err != nil {
							return err
						}
						m := make(map[pulid.PULID]int, len(v))
						for i := range v {
							m[v[i].NodeID] = v[i].Count
						}
						for i := range nodes {
							n := m[nodes[i].ID]
							if nodes[i].Edges.totalCount[2] == nil {
								nodes[i].Edges.totalCount[2] = make(map[string]int)
							}
							nodes[i].Edges.totalCount[2][alias] = n
						}
						return nil
					})
				} else {
					a.loadTotal = append(a.loadTotal, func(_ context.Context, nodes []*Account) error {
						for i := range nodes {
							n := len(nodes[i].Edges.Portfolios)
							if nodes[i].Edges.totalCount[2] == nil {
								nodes[i].Edges.totalCount[2] = make(map[string]int)
							}
							nodes[i].Edges.totalCount[2][alias] = n
						}
						return nil
					})
				}
			}
			if ignoredEdges || (args.first != nil && *args.first == 0) || (args.last != nil && *args.last == 0) {
				continue
			}

			query = pager.applyCursors(query, args.after, args.before)
			if limit := paginateLimit(args.first, args.last); limit > 0 {
				modify := limitRows(account.PortfoliosColumn, limit, pager.orderExpr(args.last != nil))
				query.modifiers = append(query.modifiers, modify)
			} else {
				query = pager.applyOrder(query, args.last != nil)
			}
			path = append(path, edgesField, nodeField)
			if field := collectedField(ctx, path...); field != nil {
				if err := query.collectField(ctx, op, *field, path, satisfies...); err != nil {
					return err
				}
			}
			a.WithNamedPortfolios(alias, func(wq *PortfolioQuery) {
				*wq = *query
			})
		case "authType":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = &AuthTypeQuery{config: a.config}
			)
			if err := query.collectField(ctx, op, field, path, satisfies...); err != nil {
				return err
			}
			a.withAuthType = query
		case "connections":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = &ConnectionQuery{config: a.config}
			)
			args := newConnectionPaginateArgs(fieldArgs(ctx, nil, path...))
			if err := validateFirstLast(args.first, args.last); err != nil {
				return fmt.Errorf("validate first and last in path %q: %w", path, err)
			}
			pager, err := newConnectionPager(args.opts)
			if err != nil {
				return fmt.Errorf("create new pager in path %q: %w", path, err)
			}
			if query, err = pager.applyFilter(query); err != nil {
				return err
			}
			ignoredEdges := !hasCollectedField(ctx, append(path, edgesField)...)
			if hasCollectedField(ctx, append(path, totalCountField)...) || hasCollectedField(ctx, append(path, pageInfoField)...) {
				hasPagination := args.after != nil || args.first != nil || args.before != nil || args.last != nil
				if hasPagination || ignoredEdges {
					query := query.Clone()
					a.loadTotal = append(a.loadTotal, func(ctx context.Context, nodes []*Account) error {
						ids := make([]driver.Value, len(nodes))
						for i := range nodes {
							ids[i] = nodes[i].ID
						}
						var v []struct {
							NodeID pulid.PULID `sql:"account_id"`
							Count  int         `sql:"count"`
						}
						query.Where(func(s *sql.Selector) {
							s.Where(sql.InValues(account.ConnectionsColumn, ids...))
						})
						if err := query.GroupBy(account.ConnectionsColumn).Aggregate(Count()).Scan(ctx, &v); err != nil {
							return err
						}
						m := make(map[pulid.PULID]int, len(v))
						for i := range v {
							m[v[i].NodeID] = v[i].Count
						}
						for i := range nodes {
							n := m[nodes[i].ID]
							if nodes[i].Edges.totalCount[4] == nil {
								nodes[i].Edges.totalCount[4] = make(map[string]int)
							}
							nodes[i].Edges.totalCount[4][alias] = n
						}
						return nil
					})
				} else {
					a.loadTotal = append(a.loadTotal, func(_ context.Context, nodes []*Account) error {
						for i := range nodes {
							n := len(nodes[i].Edges.Connections)
							if nodes[i].Edges.totalCount[4] == nil {
								nodes[i].Edges.totalCount[4] = make(map[string]int)
							}
							nodes[i].Edges.totalCount[4][alias] = n
						}
						return nil
					})
				}
			}
			if ignoredEdges || (args.first != nil && *args.first == 0) || (args.last != nil && *args.last == 0) {
				continue
			}

			query = pager.applyCursors(query, args.after, args.before)
			if limit := paginateLimit(args.first, args.last); limit > 0 {
				modify := limitRows(account.ConnectionsColumn, limit, pager.orderExpr(args.last != nil))
				query.modifiers = append(query.modifiers, modify)
			} else {
				query = pager.applyOrder(query, args.last != nil)
			}
			path = append(path, edgesField, nodeField)
			if field := collectedField(ctx, path...); field != nil {
				if err := query.collectField(ctx, op, *field, path, satisfies...); err != nil {
					return err
				}
			}
			a.WithNamedConnections(alias, func(wq *ConnectionQuery) {
				*wq = *query
			})
		}
	}
	return nil
}

type accountPaginateArgs struct {
	first, last   *int
	after, before *Cursor
	opts          []AccountPaginateOption
}

func newAccountPaginateArgs(rv map[string]interface{}) *accountPaginateArgs {
	args := &accountPaginateArgs{}
	if rv == nil {
		return args
	}
	if v := rv[firstField]; v != nil {
		args.first = v.(*int)
	}
	if v := rv[lastField]; v != nil {
		args.last = v.(*int)
	}
	if v := rv[afterField]; v != nil {
		args.after = v.(*Cursor)
	}
	if v := rv[beforeField]; v != nil {
		args.before = v.(*Cursor)
	}
	if v, ok := rv[orderByField]; ok {
		switch v := v.(type) {
		case map[string]interface{}:
			var (
				err1, err2 error
				order      = &AccountOrder{Field: &AccountOrderField{}}
			)
			if d, ok := v[directionField]; ok {
				err1 = order.Direction.UnmarshalGQL(d)
			}
			if f, ok := v[fieldField]; ok {
				err2 = order.Field.UnmarshalGQL(f)
			}
			if err1 == nil && err2 == nil {
				args.opts = append(args.opts, WithAccountOrder(order))
			}
		case *AccountOrder:
			if v != nil {
				args.opts = append(args.opts, WithAccountOrder(v))
			}
		}
	}
	if v, ok := rv[whereField].(*AccountWhereInput); ok {
		args.opts = append(args.opts, WithAccountFilter(v.Filter))
	}
	return args
}

// CollectFields tells the query-builder to eagerly load connected nodes by resolver context.
func (a *AssetQuery) CollectFields(ctx context.Context, satisfies ...string) (*AssetQuery, error) {
	fc := graphql.GetFieldContext(ctx)
	if fc == nil {
		return a, nil
	}
	if err := a.collectField(ctx, graphql.GetOperationContext(ctx), fc.Field, nil, satisfies...); err != nil {
		return nil, err
	}
	return a, nil
}

func (a *AssetQuery) collectField(ctx context.Context, op *graphql.OperationContext, field graphql.CollectedField, path []string, satisfies ...string) error {
	path = append([]string(nil), path...)
	for _, field := range graphql.CollectFields(op, field.Selections, satisfies) {
		switch field.Name {
		case "assetClass":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = &AssetClassQuery{config: a.config}
			)
			if err := query.collectField(ctx, op, field, path, satisfies...); err != nil {
				return err
			}
			a.withAssetClass = query
		case "cryptocurrency":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = &CryptocurrencyQuery{config: a.config}
			)
			if err := query.collectField(ctx, op, field, path, satisfies...); err != nil {
				return err
			}
			a.withCryptocurrency = query
		case "dailyAssetPrices":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = &DailyAssetPriceQuery{config: a.config}
			)
			args := newDailyAssetPricePaginateArgs(fieldArgs(ctx, nil, path...))
			if err := validateFirstLast(args.first, args.last); err != nil {
				return fmt.Errorf("validate first and last in path %q: %w", path, err)
			}
			pager, err := newDailyAssetPricePager(args.opts)
			if err != nil {
				return fmt.Errorf("create new pager in path %q: %w", path, err)
			}
			if query, err = pager.applyFilter(query); err != nil {
				return err
			}
			ignoredEdges := !hasCollectedField(ctx, append(path, edgesField)...)
			if hasCollectedField(ctx, append(path, totalCountField)...) || hasCollectedField(ctx, append(path, pageInfoField)...) {
				hasPagination := args.after != nil || args.first != nil || args.before != nil || args.last != nil
				if hasPagination || ignoredEdges {
					query := query.Clone()
					a.loadTotal = append(a.loadTotal, func(ctx context.Context, nodes []*Asset) error {
						ids := make([]driver.Value, len(nodes))
						for i := range nodes {
							ids[i] = nodes[i].ID
						}
						var v []struct {
							NodeID pulid.PULID `sql:"asset_id"`
							Count  int         `sql:"count"`
						}
						query.Where(func(s *sql.Selector) {
							s.Where(sql.InValues(asset.DailyAssetPricesColumn, ids...))
						})
						if err := query.GroupBy(asset.DailyAssetPricesColumn).Aggregate(Count()).Scan(ctx, &v); err != nil {
							return err
						}
						m := make(map[pulid.PULID]int, len(v))
						for i := range v {
							m[v[i].NodeID] = v[i].Count
						}
						for i := range nodes {
							n := m[nodes[i].ID]
							if nodes[i].Edges.totalCount[2] == nil {
								nodes[i].Edges.totalCount[2] = make(map[string]int)
							}
							nodes[i].Edges.totalCount[2][alias] = n
						}
						return nil
					})
				} else {
					a.loadTotal = append(a.loadTotal, func(_ context.Context, nodes []*Asset) error {
						for i := range nodes {
							n := len(nodes[i].Edges.DailyAssetPrices)
							if nodes[i].Edges.totalCount[2] == nil {
								nodes[i].Edges.totalCount[2] = make(map[string]int)
							}
							nodes[i].Edges.totalCount[2][alias] = n
						}
						return nil
					})
				}
			}
			if ignoredEdges || (args.first != nil && *args.first == 0) || (args.last != nil && *args.last == 0) {
				continue
			}

			query = pager.applyCursors(query, args.after, args.before)
			if limit := paginateLimit(args.first, args.last); limit > 0 {
				modify := limitRows(asset.DailyAssetPricesColumn, limit, pager.orderExpr(args.last != nil))
				query.modifiers = append(query.modifiers, modify)
			} else {
				query = pager.applyOrder(query, args.last != nil)
			}
			path = append(path, edgesField, nodeField)
			if field := collectedField(ctx, path...); field != nil {
				if err := query.collectField(ctx, op, *field, path, satisfies...); err != nil {
					return err
				}
			}
			a.WithNamedDailyAssetPrices(alias, func(wq *DailyAssetPriceQuery) {
				*wq = *query
			})
		}
	}
	return nil
}

type assetPaginateArgs struct {
	first, last   *int
	after, before *Cursor
	opts          []AssetPaginateOption
}

func newAssetPaginateArgs(rv map[string]interface{}) *assetPaginateArgs {
	args := &assetPaginateArgs{}
	if rv == nil {
		return args
	}
	if v := rv[firstField]; v != nil {
		args.first = v.(*int)
	}
	if v := rv[lastField]; v != nil {
		args.last = v.(*int)
	}
	if v := rv[afterField]; v != nil {
		args.after = v.(*Cursor)
	}
	if v := rv[beforeField]; v != nil {
		args.before = v.(*Cursor)
	}
	if v, ok := rv[orderByField]; ok {
		switch v := v.(type) {
		case map[string]interface{}:
			var (
				err1, err2 error
				order      = &AssetOrder{Field: &AssetOrderField{}}
			)
			if d, ok := v[directionField]; ok {
				err1 = order.Direction.UnmarshalGQL(d)
			}
			if f, ok := v[fieldField]; ok {
				err2 = order.Field.UnmarshalGQL(f)
			}
			if err1 == nil && err2 == nil {
				args.opts = append(args.opts, WithAssetOrder(order))
			}
		case *AssetOrder:
			if v != nil {
				args.opts = append(args.opts, WithAssetOrder(v))
			}
		}
	}
	if v, ok := rv[whereField].(*AssetWhereInput); ok {
		args.opts = append(args.opts, WithAssetFilter(v.Filter))
	}
	return args
}

// CollectFields tells the query-builder to eagerly load connected nodes by resolver context.
func (ac *AssetClassQuery) CollectFields(ctx context.Context, satisfies ...string) (*AssetClassQuery, error) {
	fc := graphql.GetFieldContext(ctx)
	if fc == nil {
		return ac, nil
	}
	if err := ac.collectField(ctx, graphql.GetOperationContext(ctx), fc.Field, nil, satisfies...); err != nil {
		return nil, err
	}
	return ac, nil
}

func (ac *AssetClassQuery) collectField(ctx context.Context, op *graphql.OperationContext, field graphql.CollectedField, path []string, satisfies ...string) error {
	path = append([]string(nil), path...)
	return nil
}

type assetclassPaginateArgs struct {
	first, last   *int
	after, before *Cursor
	opts          []AssetClassPaginateOption
}

func newAssetClassPaginateArgs(rv map[string]interface{}) *assetclassPaginateArgs {
	args := &assetclassPaginateArgs{}
	if rv == nil {
		return args
	}
	if v := rv[firstField]; v != nil {
		args.first = v.(*int)
	}
	if v := rv[lastField]; v != nil {
		args.last = v.(*int)
	}
	if v := rv[afterField]; v != nil {
		args.after = v.(*Cursor)
	}
	if v := rv[beforeField]; v != nil {
		args.before = v.(*Cursor)
	}
	if v, ok := rv[orderByField]; ok {
		switch v := v.(type) {
		case map[string]interface{}:
			var (
				err1, err2 error
				order      = &AssetClassOrder{Field: &AssetClassOrderField{}}
			)
			if d, ok := v[directionField]; ok {
				err1 = order.Direction.UnmarshalGQL(d)
			}
			if f, ok := v[fieldField]; ok {
				err2 = order.Field.UnmarshalGQL(f)
			}
			if err1 == nil && err2 == nil {
				args.opts = append(args.opts, WithAssetClassOrder(order))
			}
		case *AssetClassOrder:
			if v != nil {
				args.opts = append(args.opts, WithAssetClassOrder(v))
			}
		}
	}
	if v, ok := rv[whereField].(*AssetClassWhereInput); ok {
		args.opts = append(args.opts, WithAssetClassFilter(v.Filter))
	}
	return args
}

// CollectFields tells the query-builder to eagerly load connected nodes by resolver context.
func (ar *AuthRoleQuery) CollectFields(ctx context.Context, satisfies ...string) (*AuthRoleQuery, error) {
	fc := graphql.GetFieldContext(ctx)
	if fc == nil {
		return ar, nil
	}
	if err := ar.collectField(ctx, graphql.GetOperationContext(ctx), fc.Field, nil, satisfies...); err != nil {
		return nil, err
	}
	return ar, nil
}

func (ar *AuthRoleQuery) collectField(ctx context.Context, op *graphql.OperationContext, field graphql.CollectedField, path []string, satisfies ...string) error {
	path = append([]string(nil), path...)
	for _, field := range graphql.CollectFields(op, field.Selections, satisfies) {
		switch field.Name {
		case "accounts":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = &AccountQuery{config: ar.config}
			)
			args := newAccountPaginateArgs(fieldArgs(ctx, nil, path...))
			if err := validateFirstLast(args.first, args.last); err != nil {
				return fmt.Errorf("validate first and last in path %q: %w", path, err)
			}
			pager, err := newAccountPager(args.opts)
			if err != nil {
				return fmt.Errorf("create new pager in path %q: %w", path, err)
			}
			if query, err = pager.applyFilter(query); err != nil {
				return err
			}
			ignoredEdges := !hasCollectedField(ctx, append(path, edgesField)...)
			if hasCollectedField(ctx, append(path, totalCountField)...) || hasCollectedField(ctx, append(path, pageInfoField)...) {
				hasPagination := args.after != nil || args.first != nil || args.before != nil || args.last != nil
				if hasPagination || ignoredEdges {
					query := query.Clone()
					ar.loadTotal = append(ar.loadTotal, func(ctx context.Context, nodes []*AuthRole) error {
						ids := make([]driver.Value, len(nodes))
						for i := range nodes {
							ids[i] = nodes[i].ID
						}
						var v []struct {
							NodeID pulid.PULID `sql:"auth_role_id"`
							Count  int         `sql:"count"`
						}
						query.Where(func(s *sql.Selector) {
							joinT := sql.Table(authrole.AccountsTable)
							s.Join(joinT).On(s.C(account.FieldID), joinT.C(authrole.AccountsPrimaryKey[0]))
							s.Where(sql.InValues(joinT.C(authrole.AccountsPrimaryKey[1]), ids...))
							s.Select(joinT.C(authrole.AccountsPrimaryKey[1]), sql.Count("*"))
							s.GroupBy(joinT.C(authrole.AccountsPrimaryKey[1]))
						})
						if err := query.Select().Scan(ctx, &v); err != nil {
							return err
						}
						m := make(map[pulid.PULID]int, len(v))
						for i := range v {
							m[v[i].NodeID] = v[i].Count
						}
						for i := range nodes {
							n := m[nodes[i].ID]
							if nodes[i].Edges.totalCount[0] == nil {
								nodes[i].Edges.totalCount[0] = make(map[string]int)
							}
							nodes[i].Edges.totalCount[0][alias] = n
						}
						return nil
					})
				} else {
					ar.loadTotal = append(ar.loadTotal, func(_ context.Context, nodes []*AuthRole) error {
						for i := range nodes {
							n := len(nodes[i].Edges.Accounts)
							if nodes[i].Edges.totalCount[0] == nil {
								nodes[i].Edges.totalCount[0] = make(map[string]int)
							}
							nodes[i].Edges.totalCount[0][alias] = n
						}
						return nil
					})
				}
			}
			if ignoredEdges || (args.first != nil && *args.first == 0) || (args.last != nil && *args.last == 0) {
				continue
			}

			query = pager.applyCursors(query, args.after, args.before)
			if limit := paginateLimit(args.first, args.last); limit > 0 {
				modify := limitRows(authrole.AccountsPrimaryKey[1], limit, pager.orderExpr(args.last != nil))
				query.modifiers = append(query.modifiers, modify)
			} else {
				query = pager.applyOrder(query, args.last != nil)
			}
			path = append(path, edgesField, nodeField)
			if field := collectedField(ctx, path...); field != nil {
				if err := query.collectField(ctx, op, *field, path, satisfies...); err != nil {
					return err
				}
			}
			ar.WithNamedAccounts(alias, func(wq *AccountQuery) {
				*wq = *query
			})
		case "staffAccounts":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = &StaffAccountQuery{config: ar.config}
			)
			args := newStaffAccountPaginateArgs(fieldArgs(ctx, nil, path...))
			if err := validateFirstLast(args.first, args.last); err != nil {
				return fmt.Errorf("validate first and last in path %q: %w", path, err)
			}
			pager, err := newStaffAccountPager(args.opts)
			if err != nil {
				return fmt.Errorf("create new pager in path %q: %w", path, err)
			}
			if query, err = pager.applyFilter(query); err != nil {
				return err
			}
			ignoredEdges := !hasCollectedField(ctx, append(path, edgesField)...)
			if hasCollectedField(ctx, append(path, totalCountField)...) || hasCollectedField(ctx, append(path, pageInfoField)...) {
				hasPagination := args.after != nil || args.first != nil || args.before != nil || args.last != nil
				if hasPagination || ignoredEdges {
					query := query.Clone()
					ar.loadTotal = append(ar.loadTotal, func(ctx context.Context, nodes []*AuthRole) error {
						ids := make([]driver.Value, len(nodes))
						for i := range nodes {
							ids[i] = nodes[i].ID
						}
						var v []struct {
							NodeID pulid.PULID `sql:"auth_role_id"`
							Count  int         `sql:"count"`
						}
						query.Where(func(s *sql.Selector) {
							joinT := sql.Table(authrole.StaffAccountsTable)
							s.Join(joinT).On(s.C(staffaccount.FieldID), joinT.C(authrole.StaffAccountsPrimaryKey[0]))
							s.Where(sql.InValues(joinT.C(authrole.StaffAccountsPrimaryKey[1]), ids...))
							s.Select(joinT.C(authrole.StaffAccountsPrimaryKey[1]), sql.Count("*"))
							s.GroupBy(joinT.C(authrole.StaffAccountsPrimaryKey[1]))
						})
						if err := query.Select().Scan(ctx, &v); err != nil {
							return err
						}
						m := make(map[pulid.PULID]int, len(v))
						for i := range v {
							m[v[i].NodeID] = v[i].Count
						}
						for i := range nodes {
							n := m[nodes[i].ID]
							if nodes[i].Edges.totalCount[1] == nil {
								nodes[i].Edges.totalCount[1] = make(map[string]int)
							}
							nodes[i].Edges.totalCount[1][alias] = n
						}
						return nil
					})
				} else {
					ar.loadTotal = append(ar.loadTotal, func(_ context.Context, nodes []*AuthRole) error {
						for i := range nodes {
							n := len(nodes[i].Edges.StaffAccounts)
							if nodes[i].Edges.totalCount[1] == nil {
								nodes[i].Edges.totalCount[1] = make(map[string]int)
							}
							nodes[i].Edges.totalCount[1][alias] = n
						}
						return nil
					})
				}
			}
			if ignoredEdges || (args.first != nil && *args.first == 0) || (args.last != nil && *args.last == 0) {
				continue
			}

			query = pager.applyCursors(query, args.after, args.before)
			if limit := paginateLimit(args.first, args.last); limit > 0 {
				modify := limitRows(authrole.StaffAccountsPrimaryKey[1], limit, pager.orderExpr(args.last != nil))
				query.modifiers = append(query.modifiers, modify)
			} else {
				query = pager.applyOrder(query, args.last != nil)
			}
			path = append(path, edgesField, nodeField)
			if field := collectedField(ctx, path...); field != nil {
				if err := query.collectField(ctx, op, *field, path, satisfies...); err != nil {
					return err
				}
			}
			ar.WithNamedStaffAccounts(alias, func(wq *StaffAccountQuery) {
				*wq = *query
			})
		}
	}
	return nil
}

type authrolePaginateArgs struct {
	first, last   *int
	after, before *Cursor
	opts          []AuthRolePaginateOption
}

func newAuthRolePaginateArgs(rv map[string]interface{}) *authrolePaginateArgs {
	args := &authrolePaginateArgs{}
	if rv == nil {
		return args
	}
	if v := rv[firstField]; v != nil {
		args.first = v.(*int)
	}
	if v := rv[lastField]; v != nil {
		args.last = v.(*int)
	}
	if v := rv[afterField]; v != nil {
		args.after = v.(*Cursor)
	}
	if v := rv[beforeField]; v != nil {
		args.before = v.(*Cursor)
	}
	if v, ok := rv[orderByField]; ok {
		switch v := v.(type) {
		case map[string]interface{}:
			var (
				err1, err2 error
				order      = &AuthRoleOrder{Field: &AuthRoleOrderField{}}
			)
			if d, ok := v[directionField]; ok {
				err1 = order.Direction.UnmarshalGQL(d)
			}
			if f, ok := v[fieldField]; ok {
				err2 = order.Field.UnmarshalGQL(f)
			}
			if err1 == nil && err2 == nil {
				args.opts = append(args.opts, WithAuthRoleOrder(order))
			}
		case *AuthRoleOrder:
			if v != nil {
				args.opts = append(args.opts, WithAuthRoleOrder(v))
			}
		}
	}
	if v, ok := rv[whereField].(*AuthRoleWhereInput); ok {
		args.opts = append(args.opts, WithAuthRoleFilter(v.Filter))
	}
	return args
}

// CollectFields tells the query-builder to eagerly load connected nodes by resolver context.
func (at *AuthTypeQuery) CollectFields(ctx context.Context, satisfies ...string) (*AuthTypeQuery, error) {
	fc := graphql.GetFieldContext(ctx)
	if fc == nil {
		return at, nil
	}
	if err := at.collectField(ctx, graphql.GetOperationContext(ctx), fc.Field, nil, satisfies...); err != nil {
		return nil, err
	}
	return at, nil
}

func (at *AuthTypeQuery) collectField(ctx context.Context, op *graphql.OperationContext, field graphql.CollectedField, path []string, satisfies ...string) error {
	path = append([]string(nil), path...)
	return nil
}

type authtypePaginateArgs struct {
	first, last   *int
	after, before *Cursor
	opts          []AuthTypePaginateOption
}

func newAuthTypePaginateArgs(rv map[string]interface{}) *authtypePaginateArgs {
	args := &authtypePaginateArgs{}
	if rv == nil {
		return args
	}
	if v := rv[firstField]; v != nil {
		args.first = v.(*int)
	}
	if v := rv[lastField]; v != nil {
		args.last = v.(*int)
	}
	if v := rv[afterField]; v != nil {
		args.after = v.(*Cursor)
	}
	if v := rv[beforeField]; v != nil {
		args.before = v.(*Cursor)
	}
	if v, ok := rv[orderByField]; ok {
		switch v := v.(type) {
		case map[string]interface{}:
			var (
				err1, err2 error
				order      = &AuthTypeOrder{Field: &AuthTypeOrderField{}}
			)
			if d, ok := v[directionField]; ok {
				err1 = order.Direction.UnmarshalGQL(d)
			}
			if f, ok := v[fieldField]; ok {
				err2 = order.Field.UnmarshalGQL(f)
			}
			if err1 == nil && err2 == nil {
				args.opts = append(args.opts, WithAuthTypeOrder(order))
			}
		case *AuthTypeOrder:
			if v != nil {
				args.opts = append(args.opts, WithAuthTypeOrder(v))
			}
		}
	}
	if v, ok := rv[whereField].(*AuthTypeWhereInput); ok {
		args.opts = append(args.opts, WithAuthTypeFilter(v.Filter))
	}
	return args
}

// CollectFields tells the query-builder to eagerly load connected nodes by resolver context.
func (b *BlockchainQuery) CollectFields(ctx context.Context, satisfies ...string) (*BlockchainQuery, error) {
	fc := graphql.GetFieldContext(ctx)
	if fc == nil {
		return b, nil
	}
	if err := b.collectField(ctx, graphql.GetOperationContext(ctx), fc.Field, nil, satisfies...); err != nil {
		return nil, err
	}
	return b, nil
}

func (b *BlockchainQuery) collectField(ctx context.Context, op *graphql.OperationContext, field graphql.CollectedField, path []string, satisfies ...string) error {
	path = append([]string(nil), path...)
	for _, field := range graphql.CollectFields(op, field.Selections, satisfies) {
		switch field.Name {
		case "cryptocurrencies":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = &CryptocurrencyQuery{config: b.config}
			)
			args := newCryptocurrencyPaginateArgs(fieldArgs(ctx, nil, path...))
			if err := validateFirstLast(args.first, args.last); err != nil {
				return fmt.Errorf("validate first and last in path %q: %w", path, err)
			}
			pager, err := newCryptocurrencyPager(args.opts)
			if err != nil {
				return fmt.Errorf("create new pager in path %q: %w", path, err)
			}
			if query, err = pager.applyFilter(query); err != nil {
				return err
			}
			ignoredEdges := !hasCollectedField(ctx, append(path, edgesField)...)
			if hasCollectedField(ctx, append(path, totalCountField)...) || hasCollectedField(ctx, append(path, pageInfoField)...) {
				hasPagination := args.after != nil || args.first != nil || args.before != nil || args.last != nil
				if hasPagination || ignoredEdges {
					query := query.Clone()
					b.loadTotal = append(b.loadTotal, func(ctx context.Context, nodes []*Blockchain) error {
						ids := make([]driver.Value, len(nodes))
						for i := range nodes {
							ids[i] = nodes[i].ID
						}
						var v []struct {
							NodeID pulid.PULID `sql:"blockchain_id"`
							Count  int         `sql:"count"`
						}
						query.Where(func(s *sql.Selector) {
							joinT := sql.Table(blockchain.CryptocurrenciesTable)
							s.Join(joinT).On(s.C(cryptocurrency.FieldID), joinT.C(blockchain.CryptocurrenciesPrimaryKey[1]))
							s.Where(sql.InValues(joinT.C(blockchain.CryptocurrenciesPrimaryKey[0]), ids...))
							s.Select(joinT.C(blockchain.CryptocurrenciesPrimaryKey[0]), sql.Count("*"))
							s.GroupBy(joinT.C(blockchain.CryptocurrenciesPrimaryKey[0]))
						})
						if err := query.Select().Scan(ctx, &v); err != nil {
							return err
						}
						m := make(map[pulid.PULID]int, len(v))
						for i := range v {
							m[v[i].NodeID] = v[i].Count
						}
						for i := range nodes {
							n := m[nodes[i].ID]
							if nodes[i].Edges.totalCount[0] == nil {
								nodes[i].Edges.totalCount[0] = make(map[string]int)
							}
							nodes[i].Edges.totalCount[0][alias] = n
						}
						return nil
					})
				} else {
					b.loadTotal = append(b.loadTotal, func(_ context.Context, nodes []*Blockchain) error {
						for i := range nodes {
							n := len(nodes[i].Edges.Cryptocurrencies)
							if nodes[i].Edges.totalCount[0] == nil {
								nodes[i].Edges.totalCount[0] = make(map[string]int)
							}
							nodes[i].Edges.totalCount[0][alias] = n
						}
						return nil
					})
				}
			}
			if ignoredEdges || (args.first != nil && *args.first == 0) || (args.last != nil && *args.last == 0) {
				continue
			}

			query = pager.applyCursors(query, args.after, args.before)
			if limit := paginateLimit(args.first, args.last); limit > 0 {
				modify := limitRows(blockchain.CryptocurrenciesPrimaryKey[0], limit, pager.orderExpr(args.last != nil))
				query.modifiers = append(query.modifiers, modify)
			} else {
				query = pager.applyOrder(query, args.last != nil)
			}
			path = append(path, edgesField, nodeField)
			if field := collectedField(ctx, path...); field != nil {
				if err := query.collectField(ctx, op, *field, path, satisfies...); err != nil {
					return err
				}
			}
			b.WithNamedCryptocurrencies(alias, func(wq *CryptocurrencyQuery) {
				*wq = *query
			})
		case "transactions":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = &TransactionQuery{config: b.config}
			)
			args := newTransactionPaginateArgs(fieldArgs(ctx, nil, path...))
			if err := validateFirstLast(args.first, args.last); err != nil {
				return fmt.Errorf("validate first and last in path %q: %w", path, err)
			}
			pager, err := newTransactionPager(args.opts)
			if err != nil {
				return fmt.Errorf("create new pager in path %q: %w", path, err)
			}
			if query, err = pager.applyFilter(query); err != nil {
				return err
			}
			ignoredEdges := !hasCollectedField(ctx, append(path, edgesField)...)
			if hasCollectedField(ctx, append(path, totalCountField)...) || hasCollectedField(ctx, append(path, pageInfoField)...) {
				hasPagination := args.after != nil || args.first != nil || args.before != nil || args.last != nil
				if hasPagination || ignoredEdges {
					query := query.Clone()
					b.loadTotal = append(b.loadTotal, func(ctx context.Context, nodes []*Blockchain) error {
						ids := make([]driver.Value, len(nodes))
						for i := range nodes {
							ids[i] = nodes[i].ID
						}
						var v []struct {
							NodeID pulid.PULID `sql:"blockchain_id"`
							Count  int         `sql:"count"`
						}
						query.Where(func(s *sql.Selector) {
							s.Where(sql.InValues(blockchain.TransactionsColumn, ids...))
						})
						if err := query.GroupBy(blockchain.TransactionsColumn).Aggregate(Count()).Scan(ctx, &v); err != nil {
							return err
						}
						m := make(map[pulid.PULID]int, len(v))
						for i := range v {
							m[v[i].NodeID] = v[i].Count
						}
						for i := range nodes {
							n := m[nodes[i].ID]
							if nodes[i].Edges.totalCount[1] == nil {
								nodes[i].Edges.totalCount[1] = make(map[string]int)
							}
							nodes[i].Edges.totalCount[1][alias] = n
						}
						return nil
					})
				} else {
					b.loadTotal = append(b.loadTotal, func(_ context.Context, nodes []*Blockchain) error {
						for i := range nodes {
							n := len(nodes[i].Edges.Transactions)
							if nodes[i].Edges.totalCount[1] == nil {
								nodes[i].Edges.totalCount[1] = make(map[string]int)
							}
							nodes[i].Edges.totalCount[1][alias] = n
						}
						return nil
					})
				}
			}
			if ignoredEdges || (args.first != nil && *args.first == 0) || (args.last != nil && *args.last == 0) {
				continue
			}

			query = pager.applyCursors(query, args.after, args.before)
			if limit := paginateLimit(args.first, args.last); limit > 0 {
				modify := limitRows(blockchain.TransactionsColumn, limit, pager.orderExpr(args.last != nil))
				query.modifiers = append(query.modifiers, modify)
			} else {
				query = pager.applyOrder(query, args.last != nil)
			}
			path = append(path, edgesField, nodeField)
			if field := collectedField(ctx, path...); field != nil {
				if err := query.collectField(ctx, op, *field, path, satisfies...); err != nil {
					return err
				}
			}
			b.WithNamedTransactions(alias, func(wq *TransactionQuery) {
				*wq = *query
			})
		}
	}
	return nil
}

type blockchainPaginateArgs struct {
	first, last   *int
	after, before *Cursor
	opts          []BlockchainPaginateOption
}

func newBlockchainPaginateArgs(rv map[string]interface{}) *blockchainPaginateArgs {
	args := &blockchainPaginateArgs{}
	if rv == nil {
		return args
	}
	if v := rv[firstField]; v != nil {
		args.first = v.(*int)
	}
	if v := rv[lastField]; v != nil {
		args.last = v.(*int)
	}
	if v := rv[afterField]; v != nil {
		args.after = v.(*Cursor)
	}
	if v := rv[beforeField]; v != nil {
		args.before = v.(*Cursor)
	}
	if v, ok := rv[orderByField]; ok {
		switch v := v.(type) {
		case map[string]interface{}:
			var (
				err1, err2 error
				order      = &BlockchainOrder{Field: &BlockchainOrderField{}}
			)
			if d, ok := v[directionField]; ok {
				err1 = order.Direction.UnmarshalGQL(d)
			}
			if f, ok := v[fieldField]; ok {
				err2 = order.Field.UnmarshalGQL(f)
			}
			if err1 == nil && err2 == nil {
				args.opts = append(args.opts, WithBlockchainOrder(order))
			}
		case *BlockchainOrder:
			if v != nil {
				args.opts = append(args.opts, WithBlockchainOrder(v))
			}
		}
	}
	if v, ok := rv[whereField].(*BlockchainWhereInput); ok {
		args.opts = append(args.opts, WithBlockchainFilter(v.Filter))
	}
	return args
}

// CollectFields tells the query-builder to eagerly load connected nodes by resolver context.
func (c *ConnectionQuery) CollectFields(ctx context.Context, satisfies ...string) (*ConnectionQuery, error) {
	fc := graphql.GetFieldContext(ctx)
	if fc == nil {
		return c, nil
	}
	if err := c.collectField(ctx, graphql.GetOperationContext(ctx), fc.Field, nil, satisfies...); err != nil {
		return nil, err
	}
	return c, nil
}

func (c *ConnectionQuery) collectField(ctx context.Context, op *graphql.OperationContext, field graphql.CollectedField, path []string, satisfies ...string) error {
	path = append([]string(nil), path...)
	for _, field := range graphql.CollectFields(op, field.Selections, satisfies) {
		switch field.Name {
		case "source":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = &SourceQuery{config: c.config}
			)
			if err := query.collectField(ctx, op, field, path, satisfies...); err != nil {
				return err
			}
			c.withSource = query
		case "account":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = &AccountQuery{config: c.config}
			)
			if err := query.collectField(ctx, op, field, path, satisfies...); err != nil {
				return err
			}
			c.withAccount = query
		case "portfolios":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = &PortfolioQuery{config: c.config}
			)
			args := newPortfolioPaginateArgs(fieldArgs(ctx, nil, path...))
			if err := validateFirstLast(args.first, args.last); err != nil {
				return fmt.Errorf("validate first and last in path %q: %w", path, err)
			}
			pager, err := newPortfolioPager(args.opts)
			if err != nil {
				return fmt.Errorf("create new pager in path %q: %w", path, err)
			}
			if query, err = pager.applyFilter(query); err != nil {
				return err
			}
			ignoredEdges := !hasCollectedField(ctx, append(path, edgesField)...)
			if hasCollectedField(ctx, append(path, totalCountField)...) || hasCollectedField(ctx, append(path, pageInfoField)...) {
				hasPagination := args.after != nil || args.first != nil || args.before != nil || args.last != nil
				if hasPagination || ignoredEdges {
					query := query.Clone()
					c.loadTotal = append(c.loadTotal, func(ctx context.Context, nodes []*Connection) error {
						ids := make([]driver.Value, len(nodes))
						for i := range nodes {
							ids[i] = nodes[i].ID
						}
						var v []struct {
							NodeID pulid.PULID `sql:"connection_id"`
							Count  int         `sql:"count"`
						}
						query.Where(func(s *sql.Selector) {
							joinT := sql.Table(connection.PortfoliosTable)
							s.Join(joinT).On(s.C(portfolio.FieldID), joinT.C(connection.PortfoliosPrimaryKey[0]))
							s.Where(sql.InValues(joinT.C(connection.PortfoliosPrimaryKey[1]), ids...))
							s.Select(joinT.C(connection.PortfoliosPrimaryKey[1]), sql.Count("*"))
							s.GroupBy(joinT.C(connection.PortfoliosPrimaryKey[1]))
						})
						if err := query.Select().Scan(ctx, &v); err != nil {
							return err
						}
						m := make(map[pulid.PULID]int, len(v))
						for i := range v {
							m[v[i].NodeID] = v[i].Count
						}
						for i := range nodes {
							n := m[nodes[i].ID]
							if nodes[i].Edges.totalCount[2] == nil {
								nodes[i].Edges.totalCount[2] = make(map[string]int)
							}
							nodes[i].Edges.totalCount[2][alias] = n
						}
						return nil
					})
				} else {
					c.loadTotal = append(c.loadTotal, func(_ context.Context, nodes []*Connection) error {
						for i := range nodes {
							n := len(nodes[i].Edges.Portfolios)
							if nodes[i].Edges.totalCount[2] == nil {
								nodes[i].Edges.totalCount[2] = make(map[string]int)
							}
							nodes[i].Edges.totalCount[2][alias] = n
						}
						return nil
					})
				}
			}
			if ignoredEdges || (args.first != nil && *args.first == 0) || (args.last != nil && *args.last == 0) {
				continue
			}

			query = pager.applyCursors(query, args.after, args.before)
			if limit := paginateLimit(args.first, args.last); limit > 0 {
				modify := limitRows(connection.PortfoliosPrimaryKey[1], limit, pager.orderExpr(args.last != nil))
				query.modifiers = append(query.modifiers, modify)
			} else {
				query = pager.applyOrder(query, args.last != nil)
			}
			path = append(path, edgesField, nodeField)
			if field := collectedField(ctx, path...); field != nil {
				if err := query.collectField(ctx, op, *field, path, satisfies...); err != nil {
					return err
				}
			}
			c.WithNamedPortfolios(alias, func(wq *PortfolioQuery) {
				*wq = *query
			})
		}
	}
	return nil
}

type connectionPaginateArgs struct {
	first, last   *int
	after, before *Cursor
	opts          []ConnectionPaginateOption
}

func newConnectionPaginateArgs(rv map[string]interface{}) *connectionPaginateArgs {
	args := &connectionPaginateArgs{}
	if rv == nil {
		return args
	}
	if v := rv[firstField]; v != nil {
		args.first = v.(*int)
	}
	if v := rv[lastField]; v != nil {
		args.last = v.(*int)
	}
	if v := rv[afterField]; v != nil {
		args.after = v.(*Cursor)
	}
	if v := rv[beforeField]; v != nil {
		args.before = v.(*Cursor)
	}
	if v, ok := rv[orderByField]; ok {
		switch v := v.(type) {
		case map[string]interface{}:
			var (
				err1, err2 error
				order      = &ConnectionOrder{Field: &ConnectionOrderField{}}
			)
			if d, ok := v[directionField]; ok {
				err1 = order.Direction.UnmarshalGQL(d)
			}
			if f, ok := v[fieldField]; ok {
				err2 = order.Field.UnmarshalGQL(f)
			}
			if err1 == nil && err2 == nil {
				args.opts = append(args.opts, WithConnectionOrder(order))
			}
		case *ConnectionOrder:
			if v != nil {
				args.opts = append(args.opts, WithConnectionOrder(v))
			}
		}
	}
	if v, ok := rv[whereField].(*ConnectionWhereInput); ok {
		args.opts = append(args.opts, WithConnectionFilter(v.Filter))
	}
	return args
}

// CollectFields tells the query-builder to eagerly load connected nodes by resolver context.
func (c *CryptocurrencyQuery) CollectFields(ctx context.Context, satisfies ...string) (*CryptocurrencyQuery, error) {
	fc := graphql.GetFieldContext(ctx)
	if fc == nil {
		return c, nil
	}
	if err := c.collectField(ctx, graphql.GetOperationContext(ctx), fc.Field, nil, satisfies...); err != nil {
		return nil, err
	}
	return c, nil
}

func (c *CryptocurrencyQuery) collectField(ctx context.Context, op *graphql.OperationContext, field graphql.CollectedField, path []string, satisfies ...string) error {
	path = append([]string(nil), path...)
	for _, field := range graphql.CollectFields(op, field.Selections, satisfies) {
		switch field.Name {
		case "asset":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = &AssetQuery{config: c.config}
			)
			if err := query.collectField(ctx, op, field, path, satisfies...); err != nil {
				return err
			}
			c.withAsset = query
		case "blockchains":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = &BlockchainQuery{config: c.config}
			)
			args := newBlockchainPaginateArgs(fieldArgs(ctx, new(BlockchainWhereInput), path...))
			if err := validateFirstLast(args.first, args.last); err != nil {
				return fmt.Errorf("validate first and last in path %q: %w", path, err)
			}
			pager, err := newBlockchainPager(args.opts)
			if err != nil {
				return fmt.Errorf("create new pager in path %q: %w", path, err)
			}
			if query, err = pager.applyFilter(query); err != nil {
				return err
			}
			ignoredEdges := !hasCollectedField(ctx, append(path, edgesField)...)
			if hasCollectedField(ctx, append(path, totalCountField)...) || hasCollectedField(ctx, append(path, pageInfoField)...) {
				hasPagination := args.after != nil || args.first != nil || args.before != nil || args.last != nil
				if hasPagination || ignoredEdges {
					query := query.Clone()
					c.loadTotal = append(c.loadTotal, func(ctx context.Context, nodes []*Cryptocurrency) error {
						ids := make([]driver.Value, len(nodes))
						for i := range nodes {
							ids[i] = nodes[i].ID
						}
						var v []struct {
							NodeID pulid.PULID `sql:"cryptocurrency_id"`
							Count  int         `sql:"count"`
						}
						query.Where(func(s *sql.Selector) {
							joinT := sql.Table(cryptocurrency.BlockchainsTable)
							s.Join(joinT).On(s.C(blockchain.FieldID), joinT.C(cryptocurrency.BlockchainsPrimaryKey[0]))
							s.Where(sql.InValues(joinT.C(cryptocurrency.BlockchainsPrimaryKey[1]), ids...))
							s.Select(joinT.C(cryptocurrency.BlockchainsPrimaryKey[1]), sql.Count("*"))
							s.GroupBy(joinT.C(cryptocurrency.BlockchainsPrimaryKey[1]))
						})
						if err := query.Select().Scan(ctx, &v); err != nil {
							return err
						}
						m := make(map[pulid.PULID]int, len(v))
						for i := range v {
							m[v[i].NodeID] = v[i].Count
						}
						for i := range nodes {
							n := m[nodes[i].ID]
							if nodes[i].Edges.totalCount[1] == nil {
								nodes[i].Edges.totalCount[1] = make(map[string]int)
							}
							nodes[i].Edges.totalCount[1][alias] = n
						}
						return nil
					})
				} else {
					c.loadTotal = append(c.loadTotal, func(_ context.Context, nodes []*Cryptocurrency) error {
						for i := range nodes {
							n := len(nodes[i].Edges.Blockchains)
							if nodes[i].Edges.totalCount[1] == nil {
								nodes[i].Edges.totalCount[1] = make(map[string]int)
							}
							nodes[i].Edges.totalCount[1][alias] = n
						}
						return nil
					})
				}
			}
			if ignoredEdges || (args.first != nil && *args.first == 0) || (args.last != nil && *args.last == 0) {
				continue
			}

			query = pager.applyCursors(query, args.after, args.before)
			if limit := paginateLimit(args.first, args.last); limit > 0 {
				modify := limitRows(cryptocurrency.BlockchainsPrimaryKey[1], limit, pager.orderExpr(args.last != nil))
				query.modifiers = append(query.modifiers, modify)
			} else {
				query = pager.applyOrder(query, args.last != nil)
			}
			path = append(path, edgesField, nodeField)
			if field := collectedField(ctx, path...); field != nil {
				if err := query.collectField(ctx, op, *field, path, satisfies...); err != nil {
					return err
				}
			}
			c.WithNamedBlockchains(alias, func(wq *BlockchainQuery) {
				*wq = *query
			})
		}
	}
	return nil
}

type cryptocurrencyPaginateArgs struct {
	first, last   *int
	after, before *Cursor
	opts          []CryptocurrencyPaginateOption
}

func newCryptocurrencyPaginateArgs(rv map[string]interface{}) *cryptocurrencyPaginateArgs {
	args := &cryptocurrencyPaginateArgs{}
	if rv == nil {
		return args
	}
	if v := rv[firstField]; v != nil {
		args.first = v.(*int)
	}
	if v := rv[lastField]; v != nil {
		args.last = v.(*int)
	}
	if v := rv[afterField]; v != nil {
		args.after = v.(*Cursor)
	}
	if v := rv[beforeField]; v != nil {
		args.before = v.(*Cursor)
	}
	if v, ok := rv[orderByField]; ok {
		switch v := v.(type) {
		case map[string]interface{}:
			var (
				err1, err2 error
				order      = &CryptocurrencyOrder{Field: &CryptocurrencyOrderField{}}
			)
			if d, ok := v[directionField]; ok {
				err1 = order.Direction.UnmarshalGQL(d)
			}
			if f, ok := v[fieldField]; ok {
				err2 = order.Field.UnmarshalGQL(f)
			}
			if err1 == nil && err2 == nil {
				args.opts = append(args.opts, WithCryptocurrencyOrder(order))
			}
		case *CryptocurrencyOrder:
			if v != nil {
				args.opts = append(args.opts, WithCryptocurrencyOrder(v))
			}
		}
	}
	if v, ok := rv[whereField].(*CryptocurrencyWhereInput); ok {
		args.opts = append(args.opts, WithCryptocurrencyFilter(v.Filter))
	}
	return args
}

// CollectFields tells the query-builder to eagerly load connected nodes by resolver context.
func (dap *DailyAssetPriceQuery) CollectFields(ctx context.Context, satisfies ...string) (*DailyAssetPriceQuery, error) {
	fc := graphql.GetFieldContext(ctx)
	if fc == nil {
		return dap, nil
	}
	if err := dap.collectField(ctx, graphql.GetOperationContext(ctx), fc.Field, nil, satisfies...); err != nil {
		return nil, err
	}
	return dap, nil
}

func (dap *DailyAssetPriceQuery) collectField(ctx context.Context, op *graphql.OperationContext, field graphql.CollectedField, path []string, satisfies ...string) error {
	path = append([]string(nil), path...)
	for _, field := range graphql.CollectFields(op, field.Selections, satisfies) {
		switch field.Name {
		case "asset":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = &AssetQuery{config: dap.config}
			)
			if err := query.collectField(ctx, op, field, path, satisfies...); err != nil {
				return err
			}
			dap.withAsset = query
		}
	}
	return nil
}

type dailyassetpricePaginateArgs struct {
	first, last   *int
	after, before *Cursor
	opts          []DailyAssetPricePaginateOption
}

func newDailyAssetPricePaginateArgs(rv map[string]interface{}) *dailyassetpricePaginateArgs {
	args := &dailyassetpricePaginateArgs{}
	if rv == nil {
		return args
	}
	if v := rv[firstField]; v != nil {
		args.first = v.(*int)
	}
	if v := rv[lastField]; v != nil {
		args.last = v.(*int)
	}
	if v := rv[afterField]; v != nil {
		args.after = v.(*Cursor)
	}
	if v := rv[beforeField]; v != nil {
		args.before = v.(*Cursor)
	}
	if v, ok := rv[orderByField]; ok {
		switch v := v.(type) {
		case map[string]interface{}:
			var (
				err1, err2 error
				order      = &DailyAssetPriceOrder{Field: &DailyAssetPriceOrderField{}}
			)
			if d, ok := v[directionField]; ok {
				err1 = order.Direction.UnmarshalGQL(d)
			}
			if f, ok := v[fieldField]; ok {
				err2 = order.Field.UnmarshalGQL(f)
			}
			if err1 == nil && err2 == nil {
				args.opts = append(args.opts, WithDailyAssetPriceOrder(order))
			}
		case *DailyAssetPriceOrder:
			if v != nil {
				args.opts = append(args.opts, WithDailyAssetPriceOrder(v))
			}
		}
	}
	if v, ok := rv[whereField].(*DailyAssetPriceWhereInput); ok {
		args.opts = append(args.opts, WithDailyAssetPriceFilter(v.Filter))
	}
	return args
}

// CollectFields tells the query-builder to eagerly load connected nodes by resolver context.
func (e *ExchangeQuery) CollectFields(ctx context.Context, satisfies ...string) (*ExchangeQuery, error) {
	fc := graphql.GetFieldContext(ctx)
	if fc == nil {
		return e, nil
	}
	if err := e.collectField(ctx, graphql.GetOperationContext(ctx), fc.Field, nil, satisfies...); err != nil {
		return nil, err
	}
	return e, nil
}

func (e *ExchangeQuery) collectField(ctx context.Context, op *graphql.OperationContext, field graphql.CollectedField, path []string, satisfies ...string) error {
	path = append([]string(nil), path...)
	for _, field := range graphql.CollectFields(op, field.Selections, satisfies) {
		switch field.Name {
		case "transactions":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = &TransactionQuery{config: e.config}
			)
			args := newTransactionPaginateArgs(fieldArgs(ctx, new(TransactionWhereInput), path...))
			if err := validateFirstLast(args.first, args.last); err != nil {
				return fmt.Errorf("validate first and last in path %q: %w", path, err)
			}
			pager, err := newTransactionPager(args.opts)
			if err != nil {
				return fmt.Errorf("create new pager in path %q: %w", path, err)
			}
			if query, err = pager.applyFilter(query); err != nil {
				return err
			}
			ignoredEdges := !hasCollectedField(ctx, append(path, edgesField)...)
			if hasCollectedField(ctx, append(path, totalCountField)...) || hasCollectedField(ctx, append(path, pageInfoField)...) {
				hasPagination := args.after != nil || args.first != nil || args.before != nil || args.last != nil
				if hasPagination || ignoredEdges {
					query := query.Clone()
					e.loadTotal = append(e.loadTotal, func(ctx context.Context, nodes []*Exchange) error {
						ids := make([]driver.Value, len(nodes))
						for i := range nodes {
							ids[i] = nodes[i].ID
						}
						var v []struct {
							NodeID pulid.PULID `sql:"exchange_id"`
							Count  int         `sql:"count"`
						}
						query.Where(func(s *sql.Selector) {
							s.Where(sql.InValues(exchange.TransactionsColumn, ids...))
						})
						if err := query.GroupBy(exchange.TransactionsColumn).Aggregate(Count()).Scan(ctx, &v); err != nil {
							return err
						}
						m := make(map[pulid.PULID]int, len(v))
						for i := range v {
							m[v[i].NodeID] = v[i].Count
						}
						for i := range nodes {
							n := m[nodes[i].ID]
							if nodes[i].Edges.totalCount[0] == nil {
								nodes[i].Edges.totalCount[0] = make(map[string]int)
							}
							nodes[i].Edges.totalCount[0][alias] = n
						}
						return nil
					})
				} else {
					e.loadTotal = append(e.loadTotal, func(_ context.Context, nodes []*Exchange) error {
						for i := range nodes {
							n := len(nodes[i].Edges.Transactions)
							if nodes[i].Edges.totalCount[0] == nil {
								nodes[i].Edges.totalCount[0] = make(map[string]int)
							}
							nodes[i].Edges.totalCount[0][alias] = n
						}
						return nil
					})
				}
			}
			if ignoredEdges || (args.first != nil && *args.first == 0) || (args.last != nil && *args.last == 0) {
				continue
			}

			query = pager.applyCursors(query, args.after, args.before)
			if limit := paginateLimit(args.first, args.last); limit > 0 {
				modify := limitRows(exchange.TransactionsColumn, limit, pager.orderExpr(args.last != nil))
				query.modifiers = append(query.modifiers, modify)
			} else {
				query = pager.applyOrder(query, args.last != nil)
			}
			path = append(path, edgesField, nodeField)
			if field := collectedField(ctx, path...); field != nil {
				if err := query.collectField(ctx, op, *field, path, satisfies...); err != nil {
					return err
				}
			}
			e.WithNamedTransactions(alias, func(wq *TransactionQuery) {
				*wq = *query
			})
		}
	}
	return nil
}

type exchangePaginateArgs struct {
	first, last   *int
	after, before *Cursor
	opts          []ExchangePaginateOption
}

func newExchangePaginateArgs(rv map[string]interface{}) *exchangePaginateArgs {
	args := &exchangePaginateArgs{}
	if rv == nil {
		return args
	}
	if v := rv[firstField]; v != nil {
		args.first = v.(*int)
	}
	if v := rv[lastField]; v != nil {
		args.last = v.(*int)
	}
	if v := rv[afterField]; v != nil {
		args.after = v.(*Cursor)
	}
	if v := rv[beforeField]; v != nil {
		args.before = v.(*Cursor)
	}
	if v, ok := rv[orderByField]; ok {
		switch v := v.(type) {
		case map[string]interface{}:
			var (
				err1, err2 error
				order      = &ExchangeOrder{Field: &ExchangeOrderField{}}
			)
			if d, ok := v[directionField]; ok {
				err1 = order.Direction.UnmarshalGQL(d)
			}
			if f, ok := v[fieldField]; ok {
				err2 = order.Field.UnmarshalGQL(f)
			}
			if err1 == nil && err2 == nil {
				args.opts = append(args.opts, WithExchangeOrder(order))
			}
		case *ExchangeOrder:
			if v != nil {
				args.opts = append(args.opts, WithExchangeOrder(v))
			}
		}
	}
	if v, ok := rv[whereField].(*ExchangeWhereInput); ok {
		args.opts = append(args.opts, WithExchangeFilter(v.Filter))
	}
	return args
}

// CollectFields tells the query-builder to eagerly load connected nodes by resolver context.
func (po *PortfolioQuery) CollectFields(ctx context.Context, satisfies ...string) (*PortfolioQuery, error) {
	fc := graphql.GetFieldContext(ctx)
	if fc == nil {
		return po, nil
	}
	if err := po.collectField(ctx, graphql.GetOperationContext(ctx), fc.Field, nil, satisfies...); err != nil {
		return nil, err
	}
	return po, nil
}

func (po *PortfolioQuery) collectField(ctx context.Context, op *graphql.OperationContext, field graphql.CollectedField, path []string, satisfies ...string) error {
	path = append([]string(nil), path...)
	for _, field := range graphql.CollectFields(op, field.Selections, satisfies) {
		switch field.Name {
		case "account":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = &AccountQuery{config: po.config}
			)
			if err := query.collectField(ctx, op, field, path, satisfies...); err != nil {
				return err
			}
			po.withAccount = query
		case "transactions":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = &TransactionQuery{config: po.config}
			)
			args := newTransactionPaginateArgs(fieldArgs(ctx, nil, path...))
			if err := validateFirstLast(args.first, args.last); err != nil {
				return fmt.Errorf("validate first and last in path %q: %w", path, err)
			}
			pager, err := newTransactionPager(args.opts)
			if err != nil {
				return fmt.Errorf("create new pager in path %q: %w", path, err)
			}
			if query, err = pager.applyFilter(query); err != nil {
				return err
			}
			ignoredEdges := !hasCollectedField(ctx, append(path, edgesField)...)
			if hasCollectedField(ctx, append(path, totalCountField)...) || hasCollectedField(ctx, append(path, pageInfoField)...) {
				hasPagination := args.after != nil || args.first != nil || args.before != nil || args.last != nil
				if hasPagination || ignoredEdges {
					query := query.Clone()
					po.loadTotal = append(po.loadTotal, func(ctx context.Context, nodes []*Portfolio) error {
						ids := make([]driver.Value, len(nodes))
						for i := range nodes {
							ids[i] = nodes[i].ID
						}
						var v []struct {
							NodeID pulid.PULID `sql:"portfolio_id"`
							Count  int         `sql:"count"`
						}
						query.Where(func(s *sql.Selector) {
							s.Where(sql.InValues(portfolio.TransactionsColumn, ids...))
						})
						if err := query.GroupBy(portfolio.TransactionsColumn).Aggregate(Count()).Scan(ctx, &v); err != nil {
							return err
						}
						m := make(map[pulid.PULID]int, len(v))
						for i := range v {
							m[v[i].NodeID] = v[i].Count
						}
						for i := range nodes {
							n := m[nodes[i].ID]
							if nodes[i].Edges.totalCount[1] == nil {
								nodes[i].Edges.totalCount[1] = make(map[string]int)
							}
							nodes[i].Edges.totalCount[1][alias] = n
						}
						return nil
					})
				} else {
					po.loadTotal = append(po.loadTotal, func(_ context.Context, nodes []*Portfolio) error {
						for i := range nodes {
							n := len(nodes[i].Edges.Transactions)
							if nodes[i].Edges.totalCount[1] == nil {
								nodes[i].Edges.totalCount[1] = make(map[string]int)
							}
							nodes[i].Edges.totalCount[1][alias] = n
						}
						return nil
					})
				}
			}
			if ignoredEdges || (args.first != nil && *args.first == 0) || (args.last != nil && *args.last == 0) {
				continue
			}

			query = pager.applyCursors(query, args.after, args.before)
			if limit := paginateLimit(args.first, args.last); limit > 0 {
				modify := limitRows(portfolio.TransactionsColumn, limit, pager.orderExpr(args.last != nil))
				query.modifiers = append(query.modifiers, modify)
			} else {
				query = pager.applyOrder(query, args.last != nil)
			}
			path = append(path, edgesField, nodeField)
			if field := collectedField(ctx, path...); field != nil {
				if err := query.collectField(ctx, op, *field, path, satisfies...); err != nil {
					return err
				}
			}
			po.WithNamedTransactions(alias, func(wq *TransactionQuery) {
				*wq = *query
			})
		case "connections":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = &ConnectionQuery{config: po.config}
			)
			args := newConnectionPaginateArgs(fieldArgs(ctx, new(ConnectionWhereInput), path...))
			if err := validateFirstLast(args.first, args.last); err != nil {
				return fmt.Errorf("validate first and last in path %q: %w", path, err)
			}
			pager, err := newConnectionPager(args.opts)
			if err != nil {
				return fmt.Errorf("create new pager in path %q: %w", path, err)
			}
			if query, err = pager.applyFilter(query); err != nil {
				return err
			}
			ignoredEdges := !hasCollectedField(ctx, append(path, edgesField)...)
			if hasCollectedField(ctx, append(path, totalCountField)...) || hasCollectedField(ctx, append(path, pageInfoField)...) {
				hasPagination := args.after != nil || args.first != nil || args.before != nil || args.last != nil
				if hasPagination || ignoredEdges {
					query := query.Clone()
					po.loadTotal = append(po.loadTotal, func(ctx context.Context, nodes []*Portfolio) error {
						ids := make([]driver.Value, len(nodes))
						for i := range nodes {
							ids[i] = nodes[i].ID
						}
						var v []struct {
							NodeID pulid.PULID `sql:"portfolio_id"`
							Count  int         `sql:"count"`
						}
						query.Where(func(s *sql.Selector) {
							joinT := sql.Table(portfolio.ConnectionsTable)
							s.Join(joinT).On(s.C(connection.FieldID), joinT.C(portfolio.ConnectionsPrimaryKey[1]))
							s.Where(sql.InValues(joinT.C(portfolio.ConnectionsPrimaryKey[0]), ids...))
							s.Select(joinT.C(portfolio.ConnectionsPrimaryKey[0]), sql.Count("*"))
							s.GroupBy(joinT.C(portfolio.ConnectionsPrimaryKey[0]))
						})
						if err := query.Select().Scan(ctx, &v); err != nil {
							return err
						}
						m := make(map[pulid.PULID]int, len(v))
						for i := range v {
							m[v[i].NodeID] = v[i].Count
						}
						for i := range nodes {
							n := m[nodes[i].ID]
							if nodes[i].Edges.totalCount[2] == nil {
								nodes[i].Edges.totalCount[2] = make(map[string]int)
							}
							nodes[i].Edges.totalCount[2][alias] = n
						}
						return nil
					})
				} else {
					po.loadTotal = append(po.loadTotal, func(_ context.Context, nodes []*Portfolio) error {
						for i := range nodes {
							n := len(nodes[i].Edges.Connections)
							if nodes[i].Edges.totalCount[2] == nil {
								nodes[i].Edges.totalCount[2] = make(map[string]int)
							}
							nodes[i].Edges.totalCount[2][alias] = n
						}
						return nil
					})
				}
			}
			if ignoredEdges || (args.first != nil && *args.first == 0) || (args.last != nil && *args.last == 0) {
				continue
			}

			query = pager.applyCursors(query, args.after, args.before)
			if limit := paginateLimit(args.first, args.last); limit > 0 {
				modify := limitRows(portfolio.ConnectionsPrimaryKey[0], limit, pager.orderExpr(args.last != nil))
				query.modifiers = append(query.modifiers, modify)
			} else {
				query = pager.applyOrder(query, args.last != nil)
			}
			path = append(path, edgesField, nodeField)
			if field := collectedField(ctx, path...); field != nil {
				if err := query.collectField(ctx, op, *field, path, satisfies...); err != nil {
					return err
				}
			}
			po.WithNamedConnections(alias, func(wq *ConnectionQuery) {
				*wq = *query
			})
		}
	}
	return nil
}

type portfolioPaginateArgs struct {
	first, last   *int
	after, before *Cursor
	opts          []PortfolioPaginateOption
}

func newPortfolioPaginateArgs(rv map[string]interface{}) *portfolioPaginateArgs {
	args := &portfolioPaginateArgs{}
	if rv == nil {
		return args
	}
	if v := rv[firstField]; v != nil {
		args.first = v.(*int)
	}
	if v := rv[lastField]; v != nil {
		args.last = v.(*int)
	}
	if v := rv[afterField]; v != nil {
		args.after = v.(*Cursor)
	}
	if v := rv[beforeField]; v != nil {
		args.before = v.(*Cursor)
	}
	if v, ok := rv[orderByField]; ok {
		switch v := v.(type) {
		case map[string]interface{}:
			var (
				err1, err2 error
				order      = &PortfolioOrder{Field: &PortfolioOrderField{}}
			)
			if d, ok := v[directionField]; ok {
				err1 = order.Direction.UnmarshalGQL(d)
			}
			if f, ok := v[fieldField]; ok {
				err2 = order.Field.UnmarshalGQL(f)
			}
			if err1 == nil && err2 == nil {
				args.opts = append(args.opts, WithPortfolioOrder(order))
			}
		case *PortfolioOrder:
			if v != nil {
				args.opts = append(args.opts, WithPortfolioOrder(v))
			}
		}
	}
	if v, ok := rv[whereField].(*PortfolioWhereInput); ok {
		args.opts = append(args.opts, WithPortfolioFilter(v.Filter))
	}
	return args
}

// CollectFields tells the query-builder to eagerly load connected nodes by resolver context.
func (s *SourceQuery) CollectFields(ctx context.Context, satisfies ...string) (*SourceQuery, error) {
	fc := graphql.GetFieldContext(ctx)
	if fc == nil {
		return s, nil
	}
	if err := s.collectField(ctx, graphql.GetOperationContext(ctx), fc.Field, nil, satisfies...); err != nil {
		return nil, err
	}
	return s, nil
}

func (s *SourceQuery) collectField(ctx context.Context, op *graphql.OperationContext, field graphql.CollectedField, path []string, satisfies ...string) error {
	path = append([]string(nil), path...)
	for _, field := range graphql.CollectFields(op, field.Selections, satisfies) {
		switch field.Name {
		case "connections":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = &ConnectionQuery{config: s.config}
			)
			if err := query.collectField(ctx, op, field, path, satisfies...); err != nil {
				return err
			}
			s.WithNamedConnections(alias, func(wq *ConnectionQuery) {
				*wq = *query
			})
		case "sourceType":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = &SourceTypeQuery{config: s.config}
			)
			if err := query.collectField(ctx, op, field, path, satisfies...); err != nil {
				return err
			}
			s.withSourceType = query
		}
	}
	return nil
}

type sourcePaginateArgs struct {
	first, last   *int
	after, before *Cursor
	opts          []SourcePaginateOption
}

func newSourcePaginateArgs(rv map[string]interface{}) *sourcePaginateArgs {
	args := &sourcePaginateArgs{}
	if rv == nil {
		return args
	}
	if v := rv[firstField]; v != nil {
		args.first = v.(*int)
	}
	if v := rv[lastField]; v != nil {
		args.last = v.(*int)
	}
	if v := rv[afterField]; v != nil {
		args.after = v.(*Cursor)
	}
	if v := rv[beforeField]; v != nil {
		args.before = v.(*Cursor)
	}
	if v, ok := rv[orderByField]; ok {
		switch v := v.(type) {
		case map[string]interface{}:
			var (
				err1, err2 error
				order      = &SourceOrder{Field: &SourceOrderField{}}
			)
			if d, ok := v[directionField]; ok {
				err1 = order.Direction.UnmarshalGQL(d)
			}
			if f, ok := v[fieldField]; ok {
				err2 = order.Field.UnmarshalGQL(f)
			}
			if err1 == nil && err2 == nil {
				args.opts = append(args.opts, WithSourceOrder(order))
			}
		case *SourceOrder:
			if v != nil {
				args.opts = append(args.opts, WithSourceOrder(v))
			}
		}
	}
	if v, ok := rv[whereField].(*SourceWhereInput); ok {
		args.opts = append(args.opts, WithSourceFilter(v.Filter))
	}
	return args
}

// CollectFields tells the query-builder to eagerly load connected nodes by resolver context.
func (st *SourceTypeQuery) CollectFields(ctx context.Context, satisfies ...string) (*SourceTypeQuery, error) {
	fc := graphql.GetFieldContext(ctx)
	if fc == nil {
		return st, nil
	}
	if err := st.collectField(ctx, graphql.GetOperationContext(ctx), fc.Field, nil, satisfies...); err != nil {
		return nil, err
	}
	return st, nil
}

func (st *SourceTypeQuery) collectField(ctx context.Context, op *graphql.OperationContext, field graphql.CollectedField, path []string, satisfies ...string) error {
	path = append([]string(nil), path...)
	for _, field := range graphql.CollectFields(op, field.Selections, satisfies) {
		switch field.Name {
		case "sources":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = &SourceQuery{config: st.config}
			)
			args := newSourcePaginateArgs(fieldArgs(ctx, nil, path...))
			if err := validateFirstLast(args.first, args.last); err != nil {
				return fmt.Errorf("validate first and last in path %q: %w", path, err)
			}
			pager, err := newSourcePager(args.opts)
			if err != nil {
				return fmt.Errorf("create new pager in path %q: %w", path, err)
			}
			if query, err = pager.applyFilter(query); err != nil {
				return err
			}
			ignoredEdges := !hasCollectedField(ctx, append(path, edgesField)...)
			if hasCollectedField(ctx, append(path, totalCountField)...) || hasCollectedField(ctx, append(path, pageInfoField)...) {
				hasPagination := args.after != nil || args.first != nil || args.before != nil || args.last != nil
				if hasPagination || ignoredEdges {
					query := query.Clone()
					st.loadTotal = append(st.loadTotal, func(ctx context.Context, nodes []*SourceType) error {
						ids := make([]driver.Value, len(nodes))
						for i := range nodes {
							ids[i] = nodes[i].ID
						}
						var v []struct {
							NodeID pulid.PULID `sql:"source_type_sources"`
							Count  int         `sql:"count"`
						}
						query.Where(func(s *sql.Selector) {
							s.Where(sql.InValues(sourcetype.SourcesColumn, ids...))
						})
						if err := query.GroupBy(sourcetype.SourcesColumn).Aggregate(Count()).Scan(ctx, &v); err != nil {
							return err
						}
						m := make(map[pulid.PULID]int, len(v))
						for i := range v {
							m[v[i].NodeID] = v[i].Count
						}
						for i := range nodes {
							n := m[nodes[i].ID]
							if nodes[i].Edges.totalCount[0] == nil {
								nodes[i].Edges.totalCount[0] = make(map[string]int)
							}
							nodes[i].Edges.totalCount[0][alias] = n
						}
						return nil
					})
				} else {
					st.loadTotal = append(st.loadTotal, func(_ context.Context, nodes []*SourceType) error {
						for i := range nodes {
							n := len(nodes[i].Edges.Sources)
							if nodes[i].Edges.totalCount[0] == nil {
								nodes[i].Edges.totalCount[0] = make(map[string]int)
							}
							nodes[i].Edges.totalCount[0][alias] = n
						}
						return nil
					})
				}
			}
			if ignoredEdges || (args.first != nil && *args.first == 0) || (args.last != nil && *args.last == 0) {
				continue
			}

			query = pager.applyCursors(query, args.after, args.before)
			if limit := paginateLimit(args.first, args.last); limit > 0 {
				modify := limitRows(sourcetype.SourcesColumn, limit, pager.orderExpr(args.last != nil))
				query.modifiers = append(query.modifiers, modify)
			} else {
				query = pager.applyOrder(query, args.last != nil)
			}
			path = append(path, edgesField, nodeField)
			if field := collectedField(ctx, path...); field != nil {
				if err := query.collectField(ctx, op, *field, path, satisfies...); err != nil {
					return err
				}
			}
			st.WithNamedSources(alias, func(wq *SourceQuery) {
				*wq = *query
			})
		}
	}
	return nil
}

type sourcetypePaginateArgs struct {
	first, last   *int
	after, before *Cursor
	opts          []SourceTypePaginateOption
}

func newSourceTypePaginateArgs(rv map[string]interface{}) *sourcetypePaginateArgs {
	args := &sourcetypePaginateArgs{}
	if rv == nil {
		return args
	}
	if v := rv[firstField]; v != nil {
		args.first = v.(*int)
	}
	if v := rv[lastField]; v != nil {
		args.last = v.(*int)
	}
	if v := rv[afterField]; v != nil {
		args.after = v.(*Cursor)
	}
	if v := rv[beforeField]; v != nil {
		args.before = v.(*Cursor)
	}
	if v, ok := rv[orderByField]; ok {
		switch v := v.(type) {
		case map[string]interface{}:
			var (
				err1, err2 error
				order      = &SourceTypeOrder{Field: &SourceTypeOrderField{}}
			)
			if d, ok := v[directionField]; ok {
				err1 = order.Direction.UnmarshalGQL(d)
			}
			if f, ok := v[fieldField]; ok {
				err2 = order.Field.UnmarshalGQL(f)
			}
			if err1 == nil && err2 == nil {
				args.opts = append(args.opts, WithSourceTypeOrder(order))
			}
		case *SourceTypeOrder:
			if v != nil {
				args.opts = append(args.opts, WithSourceTypeOrder(v))
			}
		}
	}
	if v, ok := rv[whereField].(*SourceTypeWhereInput); ok {
		args.opts = append(args.opts, WithSourceTypeFilter(v.Filter))
	}
	return args
}

// CollectFields tells the query-builder to eagerly load connected nodes by resolver context.
func (sa *StaffAccountQuery) CollectFields(ctx context.Context, satisfies ...string) (*StaffAccountQuery, error) {
	fc := graphql.GetFieldContext(ctx)
	if fc == nil {
		return sa, nil
	}
	if err := sa.collectField(ctx, graphql.GetOperationContext(ctx), fc.Field, nil, satisfies...); err != nil {
		return nil, err
	}
	return sa, nil
}

func (sa *StaffAccountQuery) collectField(ctx context.Context, op *graphql.OperationContext, field graphql.CollectedField, path []string, satisfies ...string) error {
	path = append([]string(nil), path...)
	for _, field := range graphql.CollectFields(op, field.Selections, satisfies) {
		switch field.Name {
		case "authRoles":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = &AuthRoleQuery{config: sa.config}
			)
			args := newAuthRolePaginateArgs(fieldArgs(ctx, new(AuthRoleWhereInput), path...))
			if err := validateFirstLast(args.first, args.last); err != nil {
				return fmt.Errorf("validate first and last in path %q: %w", path, err)
			}
			pager, err := newAuthRolePager(args.opts)
			if err != nil {
				return fmt.Errorf("create new pager in path %q: %w", path, err)
			}
			if query, err = pager.applyFilter(query); err != nil {
				return err
			}
			ignoredEdges := !hasCollectedField(ctx, append(path, edgesField)...)
			if hasCollectedField(ctx, append(path, totalCountField)...) || hasCollectedField(ctx, append(path, pageInfoField)...) {
				hasPagination := args.after != nil || args.first != nil || args.before != nil || args.last != nil
				if hasPagination || ignoredEdges {
					query := query.Clone()
					sa.loadTotal = append(sa.loadTotal, func(ctx context.Context, nodes []*StaffAccount) error {
						ids := make([]driver.Value, len(nodes))
						for i := range nodes {
							ids[i] = nodes[i].ID
						}
						var v []struct {
							NodeID pulid.PULID `sql:"staff_account_id"`
							Count  int         `sql:"count"`
						}
						query.Where(func(s *sql.Selector) {
							joinT := sql.Table(staffaccount.AuthRolesTable)
							s.Join(joinT).On(s.C(authrole.FieldID), joinT.C(staffaccount.AuthRolesPrimaryKey[1]))
							s.Where(sql.InValues(joinT.C(staffaccount.AuthRolesPrimaryKey[0]), ids...))
							s.Select(joinT.C(staffaccount.AuthRolesPrimaryKey[0]), sql.Count("*"))
							s.GroupBy(joinT.C(staffaccount.AuthRolesPrimaryKey[0]))
						})
						if err := query.Select().Scan(ctx, &v); err != nil {
							return err
						}
						m := make(map[pulid.PULID]int, len(v))
						for i := range v {
							m[v[i].NodeID] = v[i].Count
						}
						for i := range nodes {
							n := m[nodes[i].ID]
							if nodes[i].Edges.totalCount[0] == nil {
								nodes[i].Edges.totalCount[0] = make(map[string]int)
							}
							nodes[i].Edges.totalCount[0][alias] = n
						}
						return nil
					})
				} else {
					sa.loadTotal = append(sa.loadTotal, func(_ context.Context, nodes []*StaffAccount) error {
						for i := range nodes {
							n := len(nodes[i].Edges.AuthRoles)
							if nodes[i].Edges.totalCount[0] == nil {
								nodes[i].Edges.totalCount[0] = make(map[string]int)
							}
							nodes[i].Edges.totalCount[0][alias] = n
						}
						return nil
					})
				}
			}
			if ignoredEdges || (args.first != nil && *args.first == 0) || (args.last != nil && *args.last == 0) {
				continue
			}

			query = pager.applyCursors(query, args.after, args.before)
			if limit := paginateLimit(args.first, args.last); limit > 0 {
				modify := limitRows(staffaccount.AuthRolesPrimaryKey[0], limit, pager.orderExpr(args.last != nil))
				query.modifiers = append(query.modifiers, modify)
			} else {
				query = pager.applyOrder(query, args.last != nil)
			}
			path = append(path, edgesField, nodeField)
			if field := collectedField(ctx, path...); field != nil {
				if err := query.collectField(ctx, op, *field, path, satisfies...); err != nil {
					return err
				}
			}
			sa.WithNamedAuthRoles(alias, func(wq *AuthRoleQuery) {
				*wq = *query
			})
		case "authType":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = &AuthTypeQuery{config: sa.config}
			)
			if err := query.collectField(ctx, op, field, path, satisfies...); err != nil {
				return err
			}
			sa.withAuthType = query
		}
	}
	return nil
}

type staffaccountPaginateArgs struct {
	first, last   *int
	after, before *Cursor
	opts          []StaffAccountPaginateOption
}

func newStaffAccountPaginateArgs(rv map[string]interface{}) *staffaccountPaginateArgs {
	args := &staffaccountPaginateArgs{}
	if rv == nil {
		return args
	}
	if v := rv[firstField]; v != nil {
		args.first = v.(*int)
	}
	if v := rv[lastField]; v != nil {
		args.last = v.(*int)
	}
	if v := rv[afterField]; v != nil {
		args.after = v.(*Cursor)
	}
	if v := rv[beforeField]; v != nil {
		args.before = v.(*Cursor)
	}
	if v, ok := rv[orderByField]; ok {
		switch v := v.(type) {
		case map[string]interface{}:
			var (
				err1, err2 error
				order      = &StaffAccountOrder{Field: &StaffAccountOrderField{}}
			)
			if d, ok := v[directionField]; ok {
				err1 = order.Direction.UnmarshalGQL(d)
			}
			if f, ok := v[fieldField]; ok {
				err2 = order.Field.UnmarshalGQL(f)
			}
			if err1 == nil && err2 == nil {
				args.opts = append(args.opts, WithStaffAccountOrder(order))
			}
		case *StaffAccountOrder:
			if v != nil {
				args.opts = append(args.opts, WithStaffAccountOrder(v))
			}
		}
	}
	if v, ok := rv[whereField].(*StaffAccountWhereInput); ok {
		args.opts = append(args.opts, WithStaffAccountFilter(v.Filter))
	}
	return args
}

// CollectFields tells the query-builder to eagerly load connected nodes by resolver context.
func (t *TransactionQuery) CollectFields(ctx context.Context, satisfies ...string) (*TransactionQuery, error) {
	fc := graphql.GetFieldContext(ctx)
	if fc == nil {
		return t, nil
	}
	if err := t.collectField(ctx, graphql.GetOperationContext(ctx), fc.Field, nil, satisfies...); err != nil {
		return nil, err
	}
	return t, nil
}

func (t *TransactionQuery) collectField(ctx context.Context, op *graphql.OperationContext, field graphql.CollectedField, path []string, satisfies ...string) error {
	path = append([]string(nil), path...)
	for _, field := range graphql.CollectFields(op, field.Selections, satisfies) {
		switch field.Name {
		case "transactionType":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = &TransactionTypeQuery{config: t.config}
			)
			if err := query.collectField(ctx, op, field, path, satisfies...); err != nil {
				return err
			}
			t.withTransactionType = query
		case "baseAsset":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = &AssetQuery{config: t.config}
			)
			if err := query.collectField(ctx, op, field, path, satisfies...); err != nil {
				return err
			}
			t.withBaseAsset = query
		case "quoteAsset":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = &AssetQuery{config: t.config}
			)
			if err := query.collectField(ctx, op, field, path, satisfies...); err != nil {
				return err
			}
			t.withQuoteAsset = query
		case "portfolio":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = &PortfolioQuery{config: t.config}
			)
			if err := query.collectField(ctx, op, field, path, satisfies...); err != nil {
				return err
			}
			t.withPortfolio = query
		case "exchange":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = &ExchangeQuery{config: t.config}
			)
			if err := query.collectField(ctx, op, field, path, satisfies...); err != nil {
				return err
			}
			t.withExchange = query
		case "blockchain":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = &BlockchainQuery{config: t.config}
			)
			if err := query.collectField(ctx, op, field, path, satisfies...); err != nil {
				return err
			}
			t.withBlockchain = query
		}
	}
	return nil
}

type transactionPaginateArgs struct {
	first, last   *int
	after, before *Cursor
	opts          []TransactionPaginateOption
}

func newTransactionPaginateArgs(rv map[string]interface{}) *transactionPaginateArgs {
	args := &transactionPaginateArgs{}
	if rv == nil {
		return args
	}
	if v := rv[firstField]; v != nil {
		args.first = v.(*int)
	}
	if v := rv[lastField]; v != nil {
		args.last = v.(*int)
	}
	if v := rv[afterField]; v != nil {
		args.after = v.(*Cursor)
	}
	if v := rv[beforeField]; v != nil {
		args.before = v.(*Cursor)
	}
	if v, ok := rv[orderByField]; ok {
		switch v := v.(type) {
		case map[string]interface{}:
			var (
				err1, err2 error
				order      = &TransactionOrder{Field: &TransactionOrderField{}}
			)
			if d, ok := v[directionField]; ok {
				err1 = order.Direction.UnmarshalGQL(d)
			}
			if f, ok := v[fieldField]; ok {
				err2 = order.Field.UnmarshalGQL(f)
			}
			if err1 == nil && err2 == nil {
				args.opts = append(args.opts, WithTransactionOrder(order))
			}
		case *TransactionOrder:
			if v != nil {
				args.opts = append(args.opts, WithTransactionOrder(v))
			}
		}
	}
	if v, ok := rv[whereField].(*TransactionWhereInput); ok {
		args.opts = append(args.opts, WithTransactionFilter(v.Filter))
	}
	return args
}

// CollectFields tells the query-builder to eagerly load connected nodes by resolver context.
func (tt *TransactionTypeQuery) CollectFields(ctx context.Context, satisfies ...string) (*TransactionTypeQuery, error) {
	fc := graphql.GetFieldContext(ctx)
	if fc == nil {
		return tt, nil
	}
	if err := tt.collectField(ctx, graphql.GetOperationContext(ctx), fc.Field, nil, satisfies...); err != nil {
		return nil, err
	}
	return tt, nil
}

func (tt *TransactionTypeQuery) collectField(ctx context.Context, op *graphql.OperationContext, field graphql.CollectedField, path []string, satisfies ...string) error {
	path = append([]string(nil), path...)
	return nil
}

type transactiontypePaginateArgs struct {
	first, last   *int
	after, before *Cursor
	opts          []TransactionTypePaginateOption
}

func newTransactionTypePaginateArgs(rv map[string]interface{}) *transactiontypePaginateArgs {
	args := &transactiontypePaginateArgs{}
	if rv == nil {
		return args
	}
	if v := rv[firstField]; v != nil {
		args.first = v.(*int)
	}
	if v := rv[lastField]; v != nil {
		args.last = v.(*int)
	}
	if v := rv[afterField]; v != nil {
		args.after = v.(*Cursor)
	}
	if v := rv[beforeField]; v != nil {
		args.before = v.(*Cursor)
	}
	if v, ok := rv[orderByField]; ok {
		switch v := v.(type) {
		case map[string]interface{}:
			var (
				err1, err2 error
				order      = &TransactionTypeOrder{Field: &TransactionTypeOrderField{}}
			)
			if d, ok := v[directionField]; ok {
				err1 = order.Direction.UnmarshalGQL(d)
			}
			if f, ok := v[fieldField]; ok {
				err2 = order.Field.UnmarshalGQL(f)
			}
			if err1 == nil && err2 == nil {
				args.opts = append(args.opts, WithTransactionTypeOrder(order))
			}
		case *TransactionTypeOrder:
			if v != nil {
				args.opts = append(args.opts, WithTransactionTypeOrder(v))
			}
		}
	}
	if v, ok := rv[whereField].(*TransactionTypeWhereInput); ok {
		args.opts = append(args.opts, WithTransactionTypeFilter(v.Filter))
	}
	return args
}

const (
	afterField     = "after"
	firstField     = "first"
	beforeField    = "before"
	lastField      = "last"
	orderByField   = "orderBy"
	directionField = "direction"
	fieldField     = "field"
	whereField     = "where"
)

func fieldArgs(ctx context.Context, whereInput interface{}, path ...string) map[string]interface{} {
	fc := graphql.GetFieldContext(ctx)
	if fc == nil {
		return nil
	}
	oc := graphql.GetOperationContext(ctx)
	for _, name := range path {
		var field *graphql.CollectedField
		for _, f := range graphql.CollectFields(oc, fc.Field.Selections, nil) {
			if f.Alias == name {
				field = &f
				break
			}
		}
		if field == nil {
			return nil
		}
		cf, err := fc.Child(ctx, *field)
		if err != nil {
			args := field.ArgumentMap(oc.Variables)
			return unmarshalArgs(ctx, whereInput, args)
		}
		fc = cf
	}
	return fc.Args
}

// unmarshalArgs allows extracting the field arguments from their raw representation.
func unmarshalArgs(ctx context.Context, whereInput interface{}, args map[string]interface{}) map[string]interface{} {
	for _, k := range []string{firstField, lastField} {
		v, ok := args[k]
		if !ok {
			continue
		}
		i, err := graphql.UnmarshalInt(v)
		if err == nil {
			args[k] = &i
		}
	}
	for _, k := range []string{beforeField, afterField} {
		v, ok := args[k]
		if !ok {
			continue
		}
		c := &Cursor{}
		if c.UnmarshalGQL(v) == nil {
			args[k] = c
		}
	}
	if v, ok := args[whereField]; ok && whereInput != nil {
		if err := graphql.UnmarshalInputFromContext(ctx, v, whereInput); err == nil {
			args[whereField] = whereInput
		}
	}

	return args
}

func limitRows(partitionBy string, limit int, orderBy ...sql.Querier) func(s *sql.Selector) {
	return func(s *sql.Selector) {
		d := sql.Dialect(s.Dialect())
		s.SetDistinct(false)
		with := d.With("src_query").
			As(s.Clone()).
			With("limited_query").
			As(
				d.Select("*").
					AppendSelectExprAs(
						sql.RowNumber().PartitionBy(partitionBy).OrderExpr(orderBy...),
						"row_number",
					).
					From(d.Table("src_query")),
			)
		t := d.Table("limited_query").As(s.TableName())
		*s = *d.Select(s.UnqualifiedColumns()...).
			From(t).
			Where(sql.LTE(t.C("row_number"), limit)).
			Prefix(with)
	}
}