docs: correctly tag code samples (#2256)

Author: IvanGoncharov

docs/APIReference-Language.md

@@ -256,7 +256,7 @@ visit(ast, {
       // leave the "Kind" node
     }
   }
-})
+});
 ```
 
 3. Generic visitors that trigger upon entering and leaving any node.

docs/Guides-ConstructingTypes.md

@@ -12,7 +12,7 @@ When you are using the `GraphQLSchema` constructor to create a schema, instead o
 
 For example, let's say we are building a simple API that lets you fetch user data for a few hardcoded users based on an id. Using `buildSchema` we could write a server with:
 
-```javascript
+```js
 var express = require('express');
 var graphqlHTTP = require('express-graphql');
 var { buildSchema } = require('graphql');
@@ -62,7 +62,7 @@ app.listen(4000, () => {
 
 We can implement this same API without using GraphQL schema language:
 
-```javascript
+```js
 var express = require('express');
 var graphqlHTTP = require('express-graphql');
 var graphql = require('graphql');

docs/Tutorial-Authentication.md

@@ -13,7 +13,7 @@ To use middleware with a GraphQL resolver, just use the middleware like you woul
 
 For example, let's say we wanted our server to log the IP address of every request, and we also want to write an API that returns the IP address of the caller. We can do the former with middleware, and the latter by accessing the `request` object in a resolver. Here's server code that implements this:
 
-```javascript
+```js
 var express = require('express');
 var graphqlHTTP = require('express-graphql');
 var { buildSchema } = require('graphql');

docs/Tutorial-BasicTypes.md

@@ -16,7 +16,7 @@ To use a list type, surround the type in square brackets, so `[Int]` is a list o
 
 Each of these types maps straightforwardly to JavaScript, so you can just return plain old JavaScript objects in APIs that return these types. Here's an example that shows how to use some of these basic types:
 
-```javascript
+```js
 var express = require('express');
 var graphqlHTTP = require('express-graphql');
 var { buildSchema } = require('graphql');

docs/Tutorial-ExpressGraphQL.md

@@ -15,7 +15,7 @@ npm install express express-graphql graphql --save
 
 Let's modify our “hello world” example so that it's an API server rather than a script that runs a single query. We can use the 'express' module to run a webserver, and instead of executing a query directly with the `graphql` function, we can use the `express-graphql` library to mount a GraphQL API server on the “/graphql” HTTP endpoint:
 
-```javascript
+```js
 var express = require('express');
 var graphqlHTTP = require('express-graphql');
 var { buildSchema } = require('graphql');

docs/Tutorial-GettingStarted.md

@@ -22,7 +22,7 @@ npm install graphql --save
 
 To handle GraphQL queries, we need a schema that defines the `Query` type, and we need an API root with a function called a “resolver” for each API endpoint. For an API that just returns “Hello world!”, we can put this code in a file named `server.js`:
 
-```javascript
+```js
 var { graphql, buildSchema } = require('graphql');
 
 // Construct a schema, using GraphQL schema language
@@ -53,7 +53,7 @@ node server.js
 
 You should see the GraphQL response printed out:
 
-```javascript
+```js
 {
   data: {
     hello: 'Hello world!';

docs/Tutorial-GraphQLClients.md

@@ -19,15 +19,15 @@ http://localhost:4000/graphql
 
 You should see the output returned as JSON:
 
-```bash
+```
 {"data":{"hello":"Hello world!"}}
 ```
 
 If you prefer to use a graphical user interface to send a test query, you can use clients such as [GraphiQL](https://github.com/graphql/graphiql) and [Insomnia](https://github.com/getinsomnia/insomnia).
 
 It's also simple to send GraphQL from the browser. Open up http://localhost:4000, open a developer console, and paste in:
 
-```javascript
+```js
 fetch('/graphql', {
   method: 'POST',
   headers: {
@@ -50,15 +50,15 @@ In this example, the query was just a hardcoded string. As your application beco
 
 For example, let's say you're running the example server from [Passing Arguments](/graphql-js/passing-arguments/) that has a schema of
 
-```javascript
+```graphql
 type Query {
   rollDice(numDice: Int!, numSides: Int): [Int]
 }
 ```
 
 You could access this from JavaScript with the code:
 
-```javascript
+```js
 var dice = 3;
 var sides = 6;
 var query = `query RollDice($dice: Int!, $sides: Int) {

docs/Tutorial-Mutations.md

@@ -10,7 +10,7 @@ If you have an API endpoint that alters data, like inserting data into a databas
 
 Let's say we have a “message of the day” server, where anyone can update the message of the day, and anyone can read the current one. The GraphQL schema for this is simply:
 
-```javascript
+```graphql
 type Mutation {
   setMessage(message: String): String
 }
@@ -24,7 +24,7 @@ It's often convenient to have a mutation that maps to a database create or updat
 
 Both mutations and queries can be handled by root resolvers, so the root that implements this schema can simply be:
 
-```javascript
+```js
 var fakeDatabase = {};
 var root = {
   setMessage: function({ message }) {
@@ -41,7 +41,7 @@ You don't need anything more than this to implement mutations. But in many cases
 
 For example, instead of a single message of the day, let's say we have many messages, indexed in a database by the `id` field, and each message has both a `content` string and an `author` string. We want a mutation API both for creating a new message and for updating an old message. We could use the schema:
 
-```javascript
+```graphql
 input MessageInput {
   content: String
   author: String
@@ -71,7 +71,7 @@ Naming input types with `Input` on the end is a useful convention, because you w
 
 Here's some runnable code that implements this schema, keeping the data in memory:
 
-```javascript
+```js
 var express = require('express');
 var graphqlHTTP = require('express-graphql');
 var { buildSchema } = require('graphql');
@@ -153,20 +153,17 @@ app.listen(4000, () => {
 
 To call a mutation, you must use the keyword `mutation` before your GraphQL query. To pass an input type, provide the data written as if it's a JSON object. For example, with the server defined above, you can create a new message and return the `id` of the new message with this operation:
 
-```javascript
+```graphql
 mutation {
-  createMessage(input: {
-    author: "andy",
-    content: "hope is a good thing",
-  }) {
+  createMessage(input: { author: "andy", content: "hope is a good thing" }) {
     id
   }
 }
 ```
 
 You can use variables to simplify mutation client logic just like you can with queries. For example, some JavaScript code that calls the server to execute this mutation is:
 
-```javascript
+```js
 var author = 'andy';
 var content = 'hope is a good thing';
 var query = `mutation CreateMessage($input: MessageInput) {

docs/Tutorial-ObjectTypes.md

@@ -10,15 +10,15 @@ In many cases, you don't want to return a number or a string from an API. You wa
 
 In GraphQL schema language, the way you define a new object type is the same way we have been defining the `Query` type in our examples. Each object can have fields that return a particular type, and methods that take arguments. For example, in the [Passing Arguments](/graphql-js/passing-arguments/) documentation, we had a method to roll some random dice:
 
-```javascript
+```graphql
 type Query {
   rollDice(numDice: Int!, numSides: Int): [Int]
 }
 ```
 
 If we wanted to have more and more methods based on a random die over time, we could implement this with a `RandomDie` object type instead.
 
-```javascript
+```graphql
 type RandomDie {
   roll(numRolls: Int!): [Int]
 }
@@ -30,7 +30,7 @@ type Query {
 
 Instead of a root-level resolver for the `RandomDie` type, we can instead use an ES6 class, where the resolvers are instance methods. This code shows how the `RandomDie` schema above can be implemented:
 
-```javascript
+```js
 class RandomDie {
   constructor(numSides) {
     this.numSides = numSides;
@@ -58,7 +58,7 @@ var root = {
 
 For fields that don't use any arguments, you can use either properties on the object or instance methods. So for the example code above, both `numSides` and `rollOnce` can actually be used to implement GraphQL fields, so that code also implements the schema of:
 
-```javascript
+```graphql
 type RandomDie {
   numSides: Int!
   rollOnce: Int!
@@ -72,7 +72,7 @@ type Query {
 
 Putting this all together, here is some sample code that runs a server with this GraphQL API:
 
-```javascript
+```js
 var express = require('express');
 var graphqlHTTP = require('express-graphql');
 var { buildSchema } = require('graphql');
@@ -132,7 +132,7 @@ app.listen(4000, () => {
 
 When you issue a GraphQL query against an API that returns object types, you can call multiple methods on the object at once by nesting the GraphQL field names. For example, if you wanted to call both `rollOnce` to roll a die once, and `roll` to roll a die three times, you could do it with this query:
 
-```javascript
+```graphql
 {
   getDie(numSides: 6) {
     rollOnce

docs/Tutorial-PassingArguments.md

@@ -8,15 +8,15 @@ next: /graphql-js/object-types/
 
 Just like a REST API, it's common to pass arguments to an endpoint in a GraphQL API. By defining the arguments in the schema language, typechecking happens automatically. Each argument must be named and have a type. For example, in the [Basic Types documentation](/graphql-js/basic-types/) we had an endpoint called `rollThreeDice`:
 
-```javascript
+```graphql
 type Query {
   rollThreeDice: [Int]
 }
 ```
 
 Instead of hardcoding “three”, we might want a more general function that rolls `numDice` dice, each of which have `numSides` sides. We can add arguments to the GraphQL schema language like this:
 
-```javascript
+```graphql
 type Query {
   rollDice(numDice: Int!, numSides: Int): [Int]
 }
@@ -26,7 +26,7 @@ The exclamation point in `Int!` indicates that `numDice` can't be null, which me
 
 So far, our resolver functions took no arguments. When a resolver takes arguments, they are passed as one “args” object, as the first argument to the function. So rollDice could be implemented as:
 
-```javascript
+```js
 var root = {
   rollDice: function(args) {
     var output = [];
@@ -40,7 +40,7 @@ var root = {
 
 It's convenient to use [ES6 destructuring assignment](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Destructuring_assignment) for these parameters, since you know what format they will be. So we can also write `rollDice` as
 
-```javascript
+```js
 var root = {
   rollDice: function({ numDice, numSides }) {
     var output = [];
@@ -56,7 +56,7 @@ If you're familiar with destructuring, this is a bit nicer because the line of c
 
 The entire code for a server that hosts this `rollDice` API is:
 
-```javascript
+```js
 var express = require('express');
 var graphqlHTTP = require('express-graphql');
 var { buildSchema } = require('graphql');
@@ -95,7 +95,7 @@ app.listen(4000, () => {
 
 When you call this API, you have to pass each argument by name. So for the server above, you could issue this GraphQL query to roll three six-sided dice:
 
-```javascript
+```graphql
 {
   rollDice(numDice: 3, numSides: 6)
 }
@@ -107,7 +107,7 @@ When you're passing arguments in code, it's generally better to avoid constructi
 
 For example, some JavaScript code that calls our server above is:
 
-```javascript
+```js
 var dice = 3;
 var sides = 6;
 var query = `query RollDice($dice: Int!, $sides: Int) {