gql_collection.go

// Code generated by ent, DO NOT EDIT.

package ent

import (
	"context"

	"entgo.io/ent/dialect/sql"
	"github.com/99designs/gqlgen/graphql"
)

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

func (da *DiscordAccountQuery) 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 "owner":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = &UserQuery{config: da.config}
			)
			if err := query.collectField(ctx, op, field, path, satisfies...); err != nil {
				return err
			}
			da.withOwner = query
		case "bot":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = &DiscordBotQuery{config: da.config}
			)
			if err := query.collectField(ctx, op, field, path, satisfies...); err != nil {
				return err
			}
			da.withBot = query
		}
	}
	return nil
}

type discordaccountPaginateArgs struct {
	first, last   *int
	after, before *Cursor
	opts          []DiscordAccountPaginateOption
}

func newDiscordAccountPaginateArgs(rv map[string]interface{}) *discordaccountPaginateArgs {
	args := &discordaccountPaginateArgs{}
	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      = &DiscordAccountOrder{Field: &DiscordAccountOrderField{}}
			)
			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, WithDiscordAccountOrder(order))
			}
		case *DiscordAccountOrder:
			if v != nil {
				args.opts = append(args.opts, WithDiscordAccountOrder(v))
			}
		}
	}
	if v, ok := rv[whereField].(*DiscordAccountWhereInput); ok {
		args.opts = append(args.opts, WithDiscordAccountFilter(v.Filter))
	}
	return args
}

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

func (db *DiscordBotQuery) 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 = &DiscordAccountQuery{config: db.config}
			)
			if err := query.collectField(ctx, op, field, path, satisfies...); err != nil {
				return err
			}
			db.withAccount = query
		case "project":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = &ProjectQuery{config: db.config}
			)
			if err := query.collectField(ctx, op, field, path, satisfies...); err != nil {
				return err
			}
			db.withProject = query
		case "repository":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = &RepositoryQuery{config: db.config}
			)
			if err := query.collectField(ctx, op, field, path, satisfies...); err != nil {
				return err
			}
			db.withRepository = query
		}
	}
	return nil
}

type discordbotPaginateArgs struct {
	first, last   *int
	after, before *Cursor
	opts          []DiscordBotPaginateOption
}

func newDiscordBotPaginateArgs(rv map[string]interface{}) *discordbotPaginateArgs {
	args := &discordbotPaginateArgs{}
	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[whereField].(*DiscordBotWhereInput); ok {
		args.opts = append(args.opts, WithDiscordBotFilter(v.Filter))
	}
	return args
}

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

func (ga *GithubAccountQuery) 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 "owner":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = &UserQuery{config: ga.config}
			)
			if err := query.collectField(ctx, op, field, path, satisfies...); err != nil {
				return err
			}
			ga.withOwner = query
		case "organizationMemberships":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = &GithubOrganizationMemberQuery{config: ga.config}
			)
			if err := query.collectField(ctx, op, field, path, satisfies...); err != nil {
				return err
			}
			ga.WithNamedOrganizationMemberships(alias, func(wq *GithubOrganizationMemberQuery) {
				*wq = *query
			})
		case "repositories":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = &RepositoryQuery{config: ga.config}
			)
			if err := query.collectField(ctx, op, field, path, satisfies...); err != nil {
				return err
			}
			ga.WithNamedRepositories(alias, func(wq *RepositoryQuery) {
				*wq = *query
			})
		}
	}
	return nil
}

type githubaccountPaginateArgs struct {
	first, last   *int
	after, before *Cursor
	opts          []GithubAccountPaginateOption
}

func newGithubAccountPaginateArgs(rv map[string]interface{}) *githubaccountPaginateArgs {
	args := &githubaccountPaginateArgs{}
	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      = &GithubAccountOrder{Field: &GithubAccountOrderField{}}
			)
			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, WithGithubAccountOrder(order))
			}
		case *GithubAccountOrder:
			if v != nil {
				args.opts = append(args.opts, WithGithubAccountOrder(v))
			}
		}
	}
	if v, ok := rv[whereField].(*GithubAccountWhereInput); ok {
		args.opts = append(args.opts, WithGithubAccountFilter(v.Filter))
	}
	return args
}

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

func (_go *GithubOrganizationQuery) 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 "members":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = &GithubOrganizationMemberQuery{config: _go.config}
			)
			if err := query.collectField(ctx, op, field, path, satisfies...); err != nil {
				return err
			}
			_go.WithNamedMembers(alias, func(wq *GithubOrganizationMemberQuery) {
				*wq = *query
			})
		case "repositories":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = &RepositoryQuery{config: _go.config}
			)
			if err := query.collectField(ctx, op, field, path, satisfies...); err != nil {
				return err
			}
			_go.WithNamedRepositories(alias, func(wq *RepositoryQuery) {
				*wq = *query
			})
		}
	}
	return nil
}

type githuborganizationPaginateArgs struct {
	first, last   *int
	after, before *Cursor
	opts          []GithubOrganizationPaginateOption
}

func newGithubOrganizationPaginateArgs(rv map[string]interface{}) *githuborganizationPaginateArgs {
	args := &githuborganizationPaginateArgs{}
	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      = &GithubOrganizationOrder{Field: &GithubOrganizationOrderField{}}
			)
			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, WithGithubOrganizationOrder(order))
			}
		case *GithubOrganizationOrder:
			if v != nil {
				args.opts = append(args.opts, WithGithubOrganizationOrder(v))
			}
		}
	}
	if v, ok := rv[whereField].(*GithubOrganizationWhereInput); ok {
		args.opts = append(args.opts, WithGithubOrganizationFilter(v.Filter))
	}
	return args
}

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

func (gom *GithubOrganizationMemberQuery) 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 "organization":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = &GithubOrganizationQuery{config: gom.config}
			)
			if err := query.collectField(ctx, op, field, path, satisfies...); err != nil {
				return err
			}
			gom.withOrganization = query
		case "account":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = &GithubAccountQuery{config: gom.config}
			)
			if err := query.collectField(ctx, op, field, path, satisfies...); err != nil {
				return err
			}
			gom.withAccount = query
		}
	}
	return nil
}

type githuborganizationmemberPaginateArgs struct {
	first, last   *int
	after, before *Cursor
	opts          []GithubOrganizationMemberPaginateOption
}

func newGithubOrganizationMemberPaginateArgs(rv map[string]interface{}) *githuborganizationmemberPaginateArgs {
	args := &githuborganizationmemberPaginateArgs{}
	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      = &GithubOrganizationMemberOrder{Field: &GithubOrganizationMemberOrderField{}}
			)
			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, WithGithubOrganizationMemberOrder(order))
			}
		case *GithubOrganizationMemberOrder:
			if v != nil {
				args.opts = append(args.opts, WithGithubOrganizationMemberOrder(v))
			}
		}
	}
	if v, ok := rv[whereField].(*GithubOrganizationMemberWhereInput); ok {
		args.opts = append(args.opts, WithGithubOrganizationMemberFilter(v.Filter))
	}
	return args
}

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

func (pr *ProjectQuery) 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 "contributors":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = &ProjectContributorQuery{config: pr.config}
			)
			if err := query.collectField(ctx, op, field, path, satisfies...); err != nil {
				return err
			}
			pr.WithNamedContributors(alias, func(wq *ProjectContributorQuery) {
				*wq = *query
			})
		case "parentProjects":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = &ProjectAssociationQuery{config: pr.config}
			)
			if err := query.collectField(ctx, op, field, path, satisfies...); err != nil {
				return err
			}
			pr.WithNamedParentProjects(alias, func(wq *ProjectAssociationQuery) {
				*wq = *query
			})
		case "childProjects":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = &ProjectAssociationQuery{config: pr.config}
			)
			if err := query.collectField(ctx, op, field, path, satisfies...); err != nil {
				return err
			}
			pr.WithNamedChildProjects(alias, func(wq *ProjectAssociationQuery) {
				*wq = *query
			})
		case "repositories":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = &RepositoryQuery{config: pr.config}
			)
			if err := query.collectField(ctx, op, field, path, satisfies...); err != nil {
				return err
			}
			pr.WithNamedRepositories(alias, func(wq *RepositoryQuery) {
				*wq = *query
			})
		case "discordBots":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = &DiscordBotQuery{config: pr.config}
			)
			if err := query.collectField(ctx, op, field, path, satisfies...); err != nil {
				return err
			}
			pr.WithNamedDiscordBots(alias, func(wq *DiscordBotQuery) {
				*wq = *query
			})
		case "sites":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = &SiteQuery{config: pr.config}
			)
			if err := query.collectField(ctx, op, field, path, satisfies...); err != nil {
				return err
			}
			pr.WithNamedSites(alias, func(wq *SiteQuery) {
				*wq = *query
			})
		case "technologies":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = &ProjectTechnologyQuery{config: pr.config}
			)
			if err := query.collectField(ctx, op, field, path, satisfies...); err != nil {
				return err
			}
			pr.WithNamedTechnologies(alias, func(wq *ProjectTechnologyQuery) {
				*wq = *query
			})
		}
	}
	return nil
}

type projectPaginateArgs struct {
	first, last   *int
	after, before *Cursor
	opts          []ProjectPaginateOption
}

func newProjectPaginateArgs(rv map[string]interface{}) *projectPaginateArgs {
	args := &projectPaginateArgs{}
	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      = &ProjectOrder{Field: &ProjectOrderField{}}
			)
			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, WithProjectOrder(order))
			}
		case *ProjectOrder:
			if v != nil {
				args.opts = append(args.opts, WithProjectOrder(v))
			}
		}
	}
	if v, ok := rv[whereField].(*ProjectWhereInput); ok {
		args.opts = append(args.opts, WithProjectFilter(v.Filter))
	}
	return args
}

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

func (pa *ProjectAssociationQuery) 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 "parent":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = &ProjectQuery{config: pa.config}
			)
			if err := query.collectField(ctx, op, field, path, satisfies...); err != nil {
				return err
			}
			pa.withParent = query
		case "child":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = &ProjectQuery{config: pa.config}
			)
			if err := query.collectField(ctx, op, field, path, satisfies...); err != nil {
				return err
			}
			pa.withChild = query
		}
	}
	return nil
}

type projectassociationPaginateArgs struct {
	first, last   *int
	after, before *Cursor
	opts          []ProjectAssociationPaginateOption
}

func newProjectAssociationPaginateArgs(rv map[string]interface{}) *projectassociationPaginateArgs {
	args := &projectassociationPaginateArgs{}
	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      = &ProjectAssociationOrder{Field: &ProjectAssociationOrderField{}}
			)
			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, WithProjectAssociationOrder(order))
			}
		case *ProjectAssociationOrder:
			if v != nil {
				args.opts = append(args.opts, WithProjectAssociationOrder(v))
			}
		}
	}
	if v, ok := rv[whereField].(*ProjectAssociationWhereInput); ok {
		args.opts = append(args.opts, WithProjectAssociationFilter(v.Filter))
	}
	return args
}

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

func (pc *ProjectContributorQuery) 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 "project":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = &ProjectQuery{config: pc.config}
			)
			if err := query.collectField(ctx, op, field, path, satisfies...); err != nil {
				return err
			}
			pc.withProject = query
		case "user":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = &UserQuery{config: pc.config}
			)
			if err := query.collectField(ctx, op, field, path, satisfies...); err != nil {
				return err
			}
			pc.withUser = query
		}
	}
	return nil
}

type projectcontributorPaginateArgs struct {
	first, last   *int
	after, before *Cursor
	opts          []ProjectContributorPaginateOption
}

func newProjectContributorPaginateArgs(rv map[string]interface{}) *projectcontributorPaginateArgs {
	args := &projectcontributorPaginateArgs{}
	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      = &ProjectContributorOrder{Field: &ProjectContributorOrderField{}}
			)
			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, WithProjectContributorOrder(order))
			}
		case *ProjectContributorOrder:
			if v != nil {
				args.opts = append(args.opts, WithProjectContributorOrder(v))
			}
		}
	}
	if v, ok := rv[whereField].(*ProjectContributorWhereInput); ok {
		args.opts = append(args.opts, WithProjectContributorFilter(v.Filter))
	}
	return args
}

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

func (pt *ProjectTechnologyQuery) 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 "project":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = &ProjectQuery{config: pt.config}
			)
			if err := query.collectField(ctx, op, field, path, satisfies...); err != nil {
				return err
			}
			pt.withProject = query
		case "technology":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = &TechnologyQuery{config: pt.config}
			)
			if err := query.collectField(ctx, op, field, path, satisfies...); err != nil {
				return err
			}
			pt.withTechnology = query
		}
	}
	return nil
}

type projecttechnologyPaginateArgs struct {
	first, last   *int
	after, before *Cursor
	opts          []ProjectTechnologyPaginateOption
}

func newProjectTechnologyPaginateArgs(rv map[string]interface{}) *projecttechnologyPaginateArgs {
	args := &projecttechnologyPaginateArgs{}
	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      = &ProjectTechnologyOrder{Field: &ProjectTechnologyOrderField{}}
			)
			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, WithProjectTechnologyOrder(order))
			}
		case *ProjectTechnologyOrder:
			if v != nil {
				args.opts = append(args.opts, WithProjectTechnologyOrder(v))
			}
		}
	}
	if v, ok := rv[whereField].(*ProjectTechnologyWhereInput); ok {
		args.opts = append(args.opts, WithProjectTechnologyFilter(v.Filter))
	}
	return args
}

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

func (r *RepositoryQuery) 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 "project":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = &ProjectQuery{config: r.config}
			)
			if err := query.collectField(ctx, op, field, path, satisfies...); err != nil {
				return err
			}
			r.withProject = query
		case "githubAccount":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = &GithubAccountQuery{config: r.config}
			)
			if err := query.collectField(ctx, op, field, path, satisfies...); err != nil {
				return err
			}
			r.withGithubAccount = query
		case "githubOrganization":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = &GithubOrganizationQuery{config: r.config}
			)
			if err := query.collectField(ctx, op, field, path, satisfies...); err != nil {
				return err
			}
			r.withGithubOrganization = query
		case "discordBots":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = &DiscordBotQuery{config: r.config}
			)
			if err := query.collectField(ctx, op, field, path, satisfies...); err != nil {
				return err
			}
			r.WithNamedDiscordBots(alias, func(wq *DiscordBotQuery) {
				*wq = *query
			})
		case "sites":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = &SiteQuery{config: r.config}
			)
			if err := query.collectField(ctx, op, field, path, satisfies...); err != nil {
				return err
			}
			r.WithNamedSites(alias, func(wq *SiteQuery) {
				*wq = *query
			})
		case "technologies":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = &RepositoryTechnologyQuery{config: r.config}
			)
			if err := query.collectField(ctx, op, field, path, satisfies...); err != nil {
				return err
			}
			r.WithNamedTechnologies(alias, func(wq *RepositoryTechnologyQuery) {
				*wq = *query
			})
		}
	}
	return nil
}

type repositoryPaginateArgs struct {
	first, last   *int
	after, before *Cursor
	opts          []RepositoryPaginateOption
}

func newRepositoryPaginateArgs(rv map[string]interface{}) *repositoryPaginateArgs {
	args := &repositoryPaginateArgs{}
	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      = &RepositoryOrder{Field: &RepositoryOrderField{}}
			)
			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, WithRepositoryOrder(order))
			}
		case *RepositoryOrder:
			if v != nil {
				args.opts = append(args.opts, WithRepositoryOrder(v))
			}
		}
	}
	if v, ok := rv[whereField].(*RepositoryWhereInput); ok {
		args.opts = append(args.opts, WithRepositoryFilter(v.Filter))
	}
	return args
}

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

func (rt *RepositoryTechnologyQuery) 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 "repository":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = &RepositoryQuery{config: rt.config}
			)
			if err := query.collectField(ctx, op, field, path, satisfies...); err != nil {
				return err
			}
			rt.withRepository = query
		case "technology":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = &TechnologyQuery{config: rt.config}
			)
			if err := query.collectField(ctx, op, field, path, satisfies...); err != nil {
				return err
			}
			rt.withTechnology = query
		}
	}
	return nil
}

type repositorytechnologyPaginateArgs struct {
	first, last   *int
	after, before *Cursor
	opts          []RepositoryTechnologyPaginateOption
}

func newRepositoryTechnologyPaginateArgs(rv map[string]interface{}) *repositorytechnologyPaginateArgs {
	args := &repositorytechnologyPaginateArgs{}
	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      = &RepositoryTechnologyOrder{Field: &RepositoryTechnologyOrderField{}}
			)
			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, WithRepositoryTechnologyOrder(order))
			}
		case *RepositoryTechnologyOrder:
			if v != nil {
				args.opts = append(args.opts, WithRepositoryTechnologyOrder(v))
			}
		}
	}
	if v, ok := rv[whereField].(*RepositoryTechnologyWhereInput); ok {
		args.opts = append(args.opts, WithRepositoryTechnologyFilter(v.Filter))
	}
	return args
}

// CollectFields tells the query-builder to eagerly load connected nodes by resolver context.
func (s *SiteQuery) CollectFields(ctx context.Context, satisfies ...string) (*SiteQuery, 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 *SiteQuery) 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 "project":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = &ProjectQuery{config: s.config}
			)
			if err := query.collectField(ctx, op, field, path, satisfies...); err != nil {
				return err
			}
			s.withProject = query
		case "repository":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = &RepositoryQuery{config: s.config}
			)
			if err := query.collectField(ctx, op, field, path, satisfies...); err != nil {
				return err
			}
			s.withRepository = query
		}
	}
	return nil
}

type sitePaginateArgs struct {
	first, last   *int
	after, before *Cursor
	opts          []SitePaginateOption
}

func newSitePaginateArgs(rv map[string]interface{}) *sitePaginateArgs {
	args := &sitePaginateArgs{}
	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      = &SiteOrder{Field: &SiteOrderField{}}
			)
			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, WithSiteOrder(order))
			}
		case *SiteOrder:
			if v != nil {
				args.opts = append(args.opts, WithSiteOrder(v))
			}
		}
	}
	if v, ok := rv[whereField].(*SiteWhereInput); ok {
		args.opts = append(args.opts, WithSiteFilter(v.Filter))
	}
	return args
}

// CollectFields tells the query-builder to eagerly load connected nodes by resolver context.
func (t *TechnologyQuery) CollectFields(ctx context.Context, satisfies ...string) (*TechnologyQuery, 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 *TechnologyQuery) 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 "parentTechnologies":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = &TechnologyAssociationQuery{config: t.config}
			)
			if err := query.collectField(ctx, op, field, path, satisfies...); err != nil {
				return err
			}
			t.WithNamedParentTechnologies(alias, func(wq *TechnologyAssociationQuery) {
				*wq = *query
			})
		case "childTechnologies":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = &TechnologyAssociationQuery{config: t.config}
			)
			if err := query.collectField(ctx, op, field, path, satisfies...); err != nil {
				return err
			}
			t.WithNamedChildTechnologies(alias, func(wq *TechnologyAssociationQuery) {
				*wq = *query
			})
		case "projects":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = &ProjectTechnologyQuery{config: t.config}
			)
			if err := query.collectField(ctx, op, field, path, satisfies...); err != nil {
				return err
			}
			t.WithNamedProjects(alias, func(wq *ProjectTechnologyQuery) {
				*wq = *query
			})
		case "repositories":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = &RepositoryTechnologyQuery{config: t.config}
			)
			if err := query.collectField(ctx, op, field, path, satisfies...); err != nil {
				return err
			}
			t.WithNamedRepositories(alias, func(wq *RepositoryTechnologyQuery) {
				*wq = *query
			})
		}
	}
	return nil
}

type technologyPaginateArgs struct {
	first, last   *int
	after, before *Cursor
	opts          []TechnologyPaginateOption
}

func newTechnologyPaginateArgs(rv map[string]interface{}) *technologyPaginateArgs {
	args := &technologyPaginateArgs{}
	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      = &TechnologyOrder{Field: &TechnologyOrderField{}}
			)
			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, WithTechnologyOrder(order))
			}
		case *TechnologyOrder:
			if v != nil {
				args.opts = append(args.opts, WithTechnologyOrder(v))
			}
		}
	}
	if v, ok := rv[whereField].(*TechnologyWhereInput); ok {
		args.opts = append(args.opts, WithTechnologyFilter(v.Filter))
	}
	return args
}

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

func (ta *TechnologyAssociationQuery) 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 "parent":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = &TechnologyQuery{config: ta.config}
			)
			if err := query.collectField(ctx, op, field, path, satisfies...); err != nil {
				return err
			}
			ta.withParent = query
		case "child":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = &TechnologyQuery{config: ta.config}
			)
			if err := query.collectField(ctx, op, field, path, satisfies...); err != nil {
				return err
			}
			ta.withChild = query
		}
	}
	return nil
}

type technologyassociationPaginateArgs struct {
	first, last   *int
	after, before *Cursor
	opts          []TechnologyAssociationPaginateOption
}

func newTechnologyAssociationPaginateArgs(rv map[string]interface{}) *technologyassociationPaginateArgs {
	args := &technologyassociationPaginateArgs{}
	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      = &TechnologyAssociationOrder{Field: &TechnologyAssociationOrderField{}}
			)
			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, WithTechnologyAssociationOrder(order))
			}
		case *TechnologyAssociationOrder:
			if v != nil {
				args.opts = append(args.opts, WithTechnologyAssociationOrder(v))
			}
		}
	}
	if v, ok := rv[whereField].(*TechnologyAssociationWhereInput); ok {
		args.opts = append(args.opts, WithTechnologyAssociationFilter(v.Filter))
	}
	return args
}

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

func (u *UserQuery) 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 "discordAccounts":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = &DiscordAccountQuery{config: u.config}
			)
			if err := query.collectField(ctx, op, field, path, satisfies...); err != nil {
				return err
			}
			u.WithNamedDiscordAccounts(alias, func(wq *DiscordAccountQuery) {
				*wq = *query
			})
		case "githubAccounts":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = &GithubAccountQuery{config: u.config}
			)
			if err := query.collectField(ctx, op, field, path, satisfies...); err != nil {
				return err
			}
			u.WithNamedGithubAccounts(alias, func(wq *GithubAccountQuery) {
				*wq = *query
			})
		case "projectContributions":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = &ProjectContributorQuery{config: u.config}
			)
			if err := query.collectField(ctx, op, field, path, satisfies...); err != nil {
				return err
			}
			u.WithNamedProjectContributions(alias, func(wq *ProjectContributorQuery) {
				*wq = *query
			})
		}
	}
	return nil
}

type userPaginateArgs struct {
	first, last   *int
	after, before *Cursor
	opts          []UserPaginateOption
}

func newUserPaginateArgs(rv map[string]interface{}) *userPaginateArgs {
	args := &userPaginateArgs{}
	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      = &UserOrder{Field: &UserOrderField{}}
			)
			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, WithUserOrder(order))
			}
		case *UserOrder:
			if v != nil {
				args.opts = append(args.opts, WithUserOrder(v))
			}
		}
	}
	if v, ok := rv[whereField].(*UserWhereInput); ok {
		args.opts = append(args.opts, WithUserFilter(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)
	}
}