Nullable types for input need a default argument even if it's null

[Anthonyzou]

With the changes in version 6.2.0 and above, input types that could be nullable did not require a default value.

This code would work before version 6.2.0

@GraphQLDescription("")
data class Book(
    val title: String?
)

Now I get the error No argument provided for a required parameter: parameter #0... unless I change the input type to:

@GraphQLDescription("")
data class Book(
    val title: String? = null
)

[samuelAndalon]

Hello, in v6 we dropped the jackson support to deserialize arguments into kotlin types using reflections which requires all types to be provided in the constructor invocation.

As highlighted in our docs
https://opensource.expediagroup.com/graphql-kotlin/docs/schema-generator/writing-schemas/arguments/#default-values

The default value information is not available, given that the info is not part of the constructor, instead kotlin adds an indirection on top of it and there is no way to access to it through reflections

a good example of why we can't just assign null is a non nullable default value

data class Foo(
  val foo: String? = "foo"
)

through reflection we cannot determine whether foo? = null or foo? = "foo"

[samuelAndalon]

However, doesn't the current behavior for nullable values violate the GraphQL spec?

It does NOT.

Consider this example

data class MyTypeInput(
    val foo: String,
    val bar: String? = "default value"
)

@Component
class SimpleQuery : Query {
    fun something(myTypeInput: MyTypeInput): String =
        myTypeInput.foo.uppercase()
}

Schema generator will output this SDL

type Query {
  something(myTypeInput: MyTypeInput!): String!
}

input MyTypeInput {
  bar: String
  foo: String!
}

MyTypeInput will have foo as non-nullable and bar as nullable

This means that we can send requests like this:

query {
  something(myTypeInput: {
    foo: "foo value"
  })
}

but we can't send queries like this

query {
  something(myTypeInput: {
    bar: "bar value"
  })
}

^^ will return a GraphQL Error, as parsing and validation process will fail given that we are not providing the non nullable foo field

so

However, GraphQL Kotlin's behavior is that foo is nullable but required, a combination which I don't believe the spec allows. "nullable types are always optional"

does not apply, foo is nullable and optional, and the error we are talking about here is a Kotlin reflections error, a runtime error (something agnostic to the GraphQL Spec).

We can work around this in our code by adding checks in our SchemaGeneratorHooks that verify that isMarkedNullable and isOptional are consistent for every input's constructor parameters, but shouldn't GraphQL Kotlin do this check itself?

we can't, currently with reflections (isMarkedNullable) does not have access to argument default values
so won't be able to know which value assign to a default value.

lets say

foo: String? = null or foo: String? = "bar"

programmatically there is no way to know which value to use null or bar as a value of foo: String.

I kind of agree that this is error prone, but there's nothing much we can do given the Kotlin Reflections limitations (we cannot access to the default values of constructor arguments)

So maybe something is worth exploring it to fail the schema generation if a given input type is not specifying a default value for a optional / nullable field.

[xenomachina]

GraphQL Kotlin's behavior is that foo is nullable but required, a combination which I don't believe the spec allows. "nullable types are always optional"

does not apply, foo is nullable and optional

The error message GraphQL Kotlin generates disagrees: "No argument provided for a required parameter"

In other words: it treats a parameter that has no default as required, even if it is nullable.

we can't, currently with reflections (isMarkedNullable) does not have access to argument default values
so won't be able to know which value assign to a default value.

Yes, I know you do not have access to the default value. I read and acknowledged the link you mentioned earlier. I am not asking for anything that requires access to the default value.

I kind of agree that this is error prone, but there's nothing much we can do given the Kotlin Reflections limitations (we cannot access to the default values of constructor arguments)

So maybe something is worth exploring it to fail the schema generation if a given input type is not specifying a default value for a optional / nullable field.

Sorry if I was unclear, but failing schema generation in cases that would result in a mismatch between what the spec says the schema should mean and the runtime behavior is exactly what I meant by:

We can work around this in our code by adding checks in our SchemaGeneratorHooks that verify that isMarkedNullable and isOptional are consistent for every input's constructor parameters, but shouldn't GraphQL Kotlin do this check itself?

I have already implemented these checks in our SchemaGeneratorHooks, but doing this feels like a workaround for something GraphQL Kotlin should be doing itself.

if (inputParam.type.isMarkedNullable) {
    require(inputParam.isOptional) { "$inputClassName.${inputParam.name} is nullable but not optional" }
}

[samuelAndalon]

Sounds good, i have created an issue, will check if we can fail the schema generation when a field is nullable and does not specify a default value (optional)

[dariuszkuc]

The error message GraphQL Kotlin generates disagrees: "No argument provided for a required parameter"
In other words: it treats a parameter that has no default as required, even if it is nullable.

Behavior is correct, while in Java every object has a default NULL value, this is not true in Kotlin and properties have to be explicitly provided.

fun foo(bar: String, baz: String?): String

In the example above baz is a nullable String but since it does not have a default value, you have to explicitly provide it, i.e. you cannot call foo("bar"). In previous versions we defaulted to setting up the null value automatically but that was misleading as in the code

fun foo(bar: String, baz: String? = "baz"): String

if you didn't specify baz property you would get null value and not the expected baz. We believe supporting arbitrary default value for optional parameters (even if not exposed in the SDL) was much bigger use case that setting null default.

Some servers can provide default value information in the schema but sadly we cannot due to the reflection limitations (see #53). Default value (and default logic associated with it) is an implementation detail of the server and does not have to be exposed in the SDL.

[samuelAndalon]

released https://github.com/ExpediaGroup/graphql-kotlin/releases/tag/6.2.2