Codegen client: Cannot pass null for optional arguments of inner types

[tsg21]

I've a problem using the dgs-codegen client (v4.9.15) which seems like a bug, but I find it hard to believe nobody else has hit this so I wonder if I am doing something wrong.

I have a schema which looks like:

type Query {
    findFoo(fooCode: String): Foo
}

type Foo {
   bars(first: Int, after: String): BarConnection
}

# Standard relay spec types...

type Bar {
  stuff : String
}

Each Foo can have many Bars, so I want to paginate the results. I believe this is a standard pattern.

I now want to run a query that looks something like:

query barPage($fooCode: String, $first : Int, $after : String) {
  findFoo(fooCode: $fooCode) {
    bars(first: $first, after: $after) {
      edges {
        node {
          stuff
        }
      }
    }
  }
}

The dgs-codegen library generates a client which is used like so:

List<Foo> fetchPageOfBars(String fooCode, int first, String after) {
   var projection = new FooProjectionRoot()
                .bars(first, after)
                    .edges()
                        .node()
                            .stuff()

     FooGraphQLQuery.newRequest()
                        .fooCode(fooCode)
                        .build(),
   // client stuff
}

Note that the fooCode is passed to the query builder, but the first and after arguments (which control the paging) are passed to the projection. This feels a little odd but I understand why it is necessary given the way the client works.

This works, unless the after argument is null which is necessary for the first page fetched. It's a cursor and we do not have a previous cursor value to provide. We hit a NullPointerException in BaseProjectionNode$InputArgument.<init>, which requires that the arguments provided are non-null. This comes from the generated code for FooProjectionRoot, which looks something like:

  public Foo_BarProjection bars(Integer first, String after) {
    Foo_BarProjection projection = new Foo_BarProjection(this, this);
    getFields().put("bars", projection);
    getInputArguments().computeIfAbsent("bars", k -> new ArrayList<>());
    InputArgument firstArg = new InputArgument("first", first);
    getInputArguments().get("bars").add(firstArg);
    InputArgument afterArg = new InputArgument("after", after);
    getInputArguments().get("bars").add(afterArg);
    return projection;
  }

The problem is apparently that new InputArgument("after", after) does not permit a null value for after.

Am I missing something here? The codegen generates a no-arg version of bars, but not one with just first. It seems legit to me to pass a null in here to represent "unspecified". My use-case feels pretty standard to me, hence my puzzlement.

Is this just a case of needing to relax a null check, or should there be some conditioning code in the projection to only add the input argument if it is non-null?

If this is a genuine issue I am happy to raise it as such.

[srinivasankavitha]

Thanks for the detailed description @tsg21. This is likely a bug in the code generation logic. Would you be able to open an issue in dgs-codegen for the same? Thanks!

[tsg21]

Thanks. Done: Netflix/dgs-codegen#314