Are variables used in scalar considered used by an operation?

[nightroman]

This post is a question in the first place. But it's also a suggestion, maybe
the specs should explicitly mention variables used in scalar expressions.

In the below query, variables $capacitance, $tolerance, $voltagerating_dc
are used in the JSON-like expression for the parameter filter. The parameter
filter is a custom scalar (Map).

query MultiMatch($product: String!, $capacitance: Float!, $tolerance: Int!, $voltagerating_dc: Int!) {
  search(
    country: "NL"
    currency: "EUR"
    distributorapi_timeout: "3s"
    q: $product
    filters: {capacitance: $capacitance, tolerance: $tolerance, voltagerating_dc_: $voltagerating_dc}
    start: 0
    limit: 5
  ) {
    hits
    results {
      part {
        id
        name
        mpn
        specs {
          attribute {
            name
          }
          value
        }
      }
    }
  }
}

Is the above GraphQL valid according to the specs?
The specs do not mention using variables in a scalar as a special case.
This fact is interpreted differently by some people, GraphQL servers, and tools.

One known GraphQL server works fine with such a query.
And one known GraphQL IDE which validates operations is happy, too.

Another known server fails with "The following variables were not used: capacitance, tolerance, voltagerating_dc."
During the related issue discussion we have discovered that different opinions exist on how to interpret the specs.
One opinion is "Variables are not used in the operation itself, using in scalar does not count, hence the error".

• ref: https://spec.graphql.org/October2021/#sec-All-Variables-Used

[martinbonnin]

What you're looking at is input value coercion (edit: not really, see below):

If a variable is provided for an input object field, the runtime value of that variable must be used. 
If the runtime value is null and the field type is non-null, a field error must be raised. 
If no runtime value is provided, the variable definition’s default value should be used. 
If the variable definition does not provide a default value, the input object field definition’s default value should be used.

The following variables were not used: capacitance, tolerance, voltagerating_dc.

This sounds like a bug to me. The variables are indeed used. The fact that they are used inside a GraphQL literal shouldn't matter IMO.

[yaacovCR]

I think the query is valid as specified according to the “all variables must be used” rule, but it is true that coercion of scalar literals containing variables is not actually specified.

[martinbonnin]

it is true that coercion of scalar literals containing variables is not actually specified.

Right 👍 . I missed that filter was a scalar, not input type. So I guess all we have is https://spec.graphql.org/October2021/#sec-Scalars.Input-Coercion which doesn't mention variables at all.

So all servers should consider the query valid. How to coerce filter might be server specific.

[andimarek]

To add to this a bit: this came up before.

In general coercion of custom scalars is a very underspecified area in the spec. To really understand it you have to look into the work @leebyron and I did some while ago to make it overall consistent (in GraphQL.js and GraphQL Java)

The variables inside literals unfortunately is a fundamental challenge: coercion of input literals is up to the custom scalar implementation and how a variable is interpreted that is referenced inside a literal is totally up to the custom scalar implementation.
This is not only a problem with "are all variables used" but also: is the variable type correct.

You could imagine a custom scalar that accepts input literals with "{someInt: Int}" and the general engine validation will not catch "{someInt: $stringVariable}" as error because it doesn't know the details of the custom Scalar.

[nightroman]

@andimarek How would GraphQL.js and GraphQL Java deal with the example query? Are all variables considered used? (If they are used then another question comes, how they are processed, but it's another story, sort of).

[andimarek]

I am very sure they are considered used as long as they appear somewhere in the operation.

The custom scalar implementation gets passed in all variables and can resolve to a variable if it encounters one: see https://github.com/graphql-java/graphql-java-extended-scalars/blob/master/src/main/java/graphql/scalars/object/ObjectScalar.java