v0.17.50
v0.17.50 v0.17.59 v0.17.58 v0.17.57 v0.17.56 v0.17.55 v0.17.54 v0.17.53 v0.17.52 v0.17.51 v0.17.49 v0.17.48 v0.17.47 v0.17.46 v0.17.45 v0.17.44 v0.17.43 v0.17.42 v0.17.41 v0.17.40 master

Field Collection

Determining which fields were requested by a query
[edit]
You are looking at the docs for an older version (v0.17.50). The latest version is v0.17.59.

Often it is useful to know which fields were queried for in a resolver. Having this information can allow a resolver to only fetch the set of fields required from a data source, rather than over-fetching everything and allowing gqlgen to do the rest.

This process is known as Field Collection — gqlgen automatically does this in order to know which fields should be a part of the response payload. The set of collected fields does however depend on the type being resolved. Queries can contain fragments, and resolvers can return interfaces and unions, therefore the set of collected fields cannot be fully determined until the type of the resolved object is known.

Within a resolver, there are several API methods available to query the selected fields.

CollectAllFields

CollectAllFields is the simplest way to get the set of queried fields. It will return a slice of strings of the field names from the query. This will be a unique set of fields, and will return all fragment fields, ignoring fragment Type Conditions.

Given the following example query:

query {
    foo {
        fieldA
        ... on Bar {
            fieldB
        }
        ... on Baz {
            fieldC
        }
    }
}

Calling CollectAllFields from a resolver will yield a string slice containing fieldA, fieldB, and fieldC.

CollectFieldsCtx

CollectFieldsCtx is useful in cases where more information on matches is required, or the set of collected fields should match fragment type conditions for a resolved type. CollectFieldsCtx takes a satisfies parameter, which should be a slice of strings of types that the resolved type will satisfy.

For example, given the following schema:

interface Shape {
    area: Float
}
type Circle implements Shape {
    radius: Float
    area: Float
}
union Shapes = Circle

The type Circle would satisfy Circle, Shape, and Shapes — these values should be passed to CollectFieldsCtx to get the set of collected fields for a resolved Circle object.

Note

CollectFieldsCtx is just a convenience wrapper around CollectFields that calls the later with the selection set automatically passed through from the resolver context.

Practical example

Say we have the following GraphQL query

query {
  flowBlocks {
    id
    block {
      id
      title
      type
      choices {
        id
        title
        description
        slug
      }
    }
  }
}

We don’t want to overfetch our database so we want to know which field are requested. Here is an example which get’s all requested field as convenient string slice, which can be easily checked.

func GetPreloads(ctx context.Context) []string {
	return GetNestedPreloads(
		graphql.GetOperationContext(ctx),
		graphql.CollectFieldsCtx(ctx, nil),
		"",
	)
}

func GetNestedPreloads(ctx *graphql.OperationContext, fields []graphql.CollectedField, prefix string) (preloads []string) {
	for _, column := range fields {
		prefixColumn := GetPreloadString(prefix, column.Name)
		preloads = append(preloads, prefixColumn)
		preloads = append(preloads, GetNestedPreloads(ctx, graphql.CollectFields(ctx, column.Selections, nil), prefixColumn)...)
	}
	return
}

func GetPreloadString(prefix, name string) string {
	if len(prefix) > 0 {
		return prefix + "." + name
	}
	return name
}

So if we call these helpers in our resolver:

func (r *queryResolver) FlowBlocks(ctx context.Context) ([]*FlowBlock, error) {
	preloads := GetPreloads(ctx)

it will result in the following string slice:

["id", "block", "block.id", "block.title", "block.type", "block.choices", "block.choices.id", "block.choices.title", "block.choices.description", "block.choices.slug"]