Choose case for serializing/deserializing

[angristan]

The main issue I'm facing is for serialization.

Serializing

For example when I want to serialize my input schema as the body of a POST HTTP request:

schema @server(port: 8000) @upstream(baseURL: "http://localhost:8008") {
  query: Query
}

type Query {
  searchUser(input: UserSearch): [User]!
    @http(
      method: POST
      path: "/users/search"
      body: "{{.args.input}}"
    )
}

input UserSearch {
  emailAddress: String!

type User {
  id: ID!
  name: String!
  email: String!
}

The input will be serialiezed as {"emailAddress":"test@example.com"}, but I want email_address as this is what my API expects.

• I could rename the field but GraphQL schemas are usually camel case and this breaks consistency
• I could manually define the payload as body: "{ \"email_address\": \"{{.args.input.emailAddress}}\" }" but this is ugly and gets tedious for large payloads
• It doesn't seem that the @modify directive can help here
  Is there any other way?

Deserializing

Let's say my API returns:

{
  "id": "123",
  "email_address": "sample@sample"
}

And my schema is:

type User {
  id: ID!
  emailAddress: String
}

Then emailAddress would be null or would fail if it was of type String!.

Thus, I need to do:

type User {
  id: ID!
  email_address: String!
}

which breaks camel case consistency.

To still be able to query the emailAddress field in my GraphQL schema as camel case, I found these solutions:

initiator_id: String! @modify(name: "initiatorId")
# or
initiatorId: String @expr(body: "{{.value.initiator_id}}")

Which are OK, but I feel like there could be a more elegant/automated solution to specify the case 🤔

[bnchi]

@angristan Can you check my comment here : #2483 (comment)

is this what you're trying to do ?

Because in the current behavior you can set @modify on an input field and it will work just fine

[tusharmath]

Proposing the following feature here:

#2483

Hope that helps.