A modern programming language that makes developers happier.

kotlinlang

:wave: I have a question about <https://www.apollographql.com/docs/kotlin/testing/data-builders/|data builders> — from what I see, the builders are pretty much generated from the schema, and the queries only contribute a helper function with top-level properties. This makes it very flexible, in the sense that there's no help from the compiler regarding e.g. which fields are fetched. For example given
```query Foo { 
  bar { baz }
}```
the builders allow me to write
```Foo.Builder {
 bar = buildBar { 
    someUnrelatedPropertyInBar = ""
    // I'm allowed to leave `baz` unset
  }
}```
is that right or I'm missing something? Is there a way for a less flexible API, one that mirrors the queries and would give a typesafe way to build a json for a given data (one that forces me to pass the fetched fields, and doesn't allow passing fields that aren't fetched)?

That's correct, they are based on the schema.

Actually the previous iteration (that we called 'test builders') were query based, but they were prone to a potential 'exponential explosion' of generated code because they were response based.

can you give an example of such explosion? Wouldn't such safe API need ~one method per level of nesting in the queries, where each level is a method and each field is an argument?

I understand it would require several methods for each query, but it'd still be linear (with maybe large constant :smile:) and not necessarily exponential :thinking_face:

It's about polymorphism - each `... on Xyz` fragment can have a different shape, which needs to generate its own model - and if you have nested ones that leads to a lot of combinations. You can read about this in <https://github.com/apollographql/apollo-kotlin/issues/3144|this issue> about the responseBased codegen :slightly_smiling_face:

I'll take a look, thanks :slightly_smiling_face: And finally a lazyweb question — I vaguely recall something about Apollo artifacts that might help with parsing schema/queries in Kotlin, is there something like that that might help me building/generating my own builders?

you're probably thinking of <https://www.apollographql.com/docs/kotlin/advanced/apollo-ast|Apollo AST>

sure thing!

(re data builders: one advantage with them being based on the schema is that you can re-use the data for different tests)

what do you mean different tests? :thinking_face:

I mean you can reuse the result of `buildXyz {}` and not be bound to a specific query

(assuming you're using this for tests, but actually don't know :blush:)

yeah, in practice we'd have a fragment in such case, which I'd imagine would be reusable :slightly_smiling_face: