Taking into account Apollo fragment interpolation

[jnwng]

This PR is attempting to resolve #29.

In Apollo, fragment interpolation is now valid within the gql TaggedTemplateLiteral, but only outside of top-level structures like query or mutation. In other clients like Lokka and Relay, fragment interpolation actually results in a document substitution, but in Apollo this gets evaluated at runtime, so we only need to validate the location of the fragment interpolation.

We'll do this by evaluating two things:

1. Making sure that an error isn't thrown when a valid interpolation is found
2. Throwing an error when an invalid interpolation is found
   In Apollo, fragment interpolation is invalid inside of query structures, so a document like this should fail:

gql`query { someField ${SomeFragment} }`

NOTE: the evaluation strategy for checking to see if we're outside of a structure is naively evaluating the number of open and closing brackets, not whether or not they're matching. this means that

gql`query }{ ${SomeFragment}`

won't throw an error for invalid interpolation (but the graphql parser itself will throw an error on the invalid document structure). this just seemed easier to do.

• If this PR is a new feature, reference an issue where a consensus about the design was reached (not necessary for small changes)
• Make sure all of the significant new logic is covered by tests
• Rebase your changes on master so that they can be merged easily
• Make sure all tests and linter rules pass
• Update CHANGELOG.md with your change (omitted because I'm not fully sure I should be doing this)
• Add your name and email to the AUTHORS file (optional) (omitted because this file does not exist)
• If this was a change that affects the external API, update the docs and post a link to the PR in the discussion (omitted because it does not change an external API)

Steps to Reproduce

Recently, graphql-fragments was deprecated and its functionality baked into graphql-tag itself, allowing one to interpolate fragments directly into queries themselves, like so:

gql`
  query {
    someField
    ...SomeFragment
  }
  ${SomeFragment}
`

However, eslint-plugin-graphql will report this as a warning / error because interpolation was previously not valid in gql queries for the Apollo client.

[jnwng]

I had one question - this affects the default behavior of the gql tag. In the case where the environment is not specified, this will throw an error for an otherwise valid Apollo-style fragment interpolation. Should I make the check that throws an error in default mode not throw an error to match the Apollo behavior?

[stubailo]

Yeah let's make the default compatible with 'graphql-tag' in general.

[eigenmannmartin]

@stubailo @jnwng What is the state of this pr? Can i help somehow to get it finished? 👼

[ghost]

bump

[turadg]

fwiw, I tried in the #eslint-plugin-graphql channel. Then to work around this I forked, merged jnwng:jw/apollo-fragments, and published a private package.

[jnwng]

@stubailo @tmeasday @helfer anything i can do to help get a review for this PR? happy to add more tests if its not super clear what's happening here.

[helfer]

@jnwng Sorry this slipped under my radar. Looks good to me, I'll merge it and release a new version!

[helfer]

0.5.0 published. Thank you all for your patience, and special thanks to @jonwong for fixing this!