fix(comments): pr comments

Author: abhiaiyer91

content/GraphQL-Binding/01-Overview.md

@@ -4,35 +4,36 @@
 
 ## Description
 
-A simple way to interact with a GraphQL API is to make an HTTP `POST` request to
-a GraphQL server:
-
-Using JavaScript's `fetch`:
+The most straightforward way to interact with a GraphQL API is to make an HTTP POST request to a GraphQL server, for example using JavaScript's fetch:
 
 ```js
 require('isomorphic-fetch');
 
+const query = `
+  query {
+    posts {
+      title
+    }
+  }
+`;
+
 fetch('https://1jzxrj179.lp.gql.zone/graphql', {
   method: 'POST',
   headers: { 'Content-Type': 'application/json' },
-  body: JSON.stringify({ query: '{ posts { title } }' }),
+  body: JSON.stringify({ query }),
 })
   .then(res => res.json())
   .then(res => console.log(res.data));
 ```
 
 GraphQL bindings provide a convenient interface for interacting with a GraphQL
 API with your favorite programming language. Instead of sending queries as strings
-like we demonstrated above, you can invoke a binding function which constructs GraphQL requests and sends it to a GraphQL server for you.
+like we demonstrated above, you can invoke a binding function which constructs a GraphQL request and sends it to a GraphQL server for you.
 
-The API of a GraphQL binding is very flexible, making them the perfect tool for
-use cases like: accessing GraphQL APIs from scripts or webhooks, `service-to-service` communication in a microservice architecture, or building
-GraphQL API gateways.
+Bindings can be useful in combination with statically
+typed languages that IDEs and code editors to leverage tooling that can be configured in such a way that they validate GraphQL requests at compile time or even provide auto-completion for an advanced developer experience.
 
-To take it even further, bindings can be useful in combination with statically
-typed languages that IDEs and code editors to leverage tooling that can be configuredin such a way that they validate GraphQL requests at compile time or even provide auto-completion for an advanced developer experience.
-
-A perspective that onboards both new engineers and seasoned teams is to think of GraphQL bindings as an auto-generated SDK (software development kit) for GraphQL APIs.
+A perspective that onboards engineers is to think of GraphQL bindings as an auto-generated [SDK](https://en.wikipedia.org/wiki/Software_development_kit) for GraphQL APIs.
 
 ![](../../assets/bindings.png)
 
@@ -73,13 +74,13 @@ Now install the package `graphql-binding-example` through NPM or yarn:
 
 ```sh
 yarn add graphql-binding-example
-
+# or
 npm install graphql-binding-example
 ```
 
-To see the code for this example binding, you can view that [here](https://github.com/graphql-binding/graphql-binding-example-service). You can learn how to create your own binding [here](./04-Creating-your-own-Binding.md)).
+> You can find code for the `graphql-binding-example` [here](https://github.com/graphql-binding/graphql-binding-example-service). Learn how to create your own GraphQL binding [here](https://github.com/prisma/oss.prisma.io/blob/GraphQLBinding/content/GraphQL-Binding/04-Creating-your-own-Binding.md).
 
-Here are three scenarios how this binding could be used:
+In the following, we'll discuss three scenarios illustrating how the example binding can be used.
 
 ### 1. Usage in a simple Node script
 

content/GraphQL-Binding/02-API-Reference.md

@@ -83,7 +83,7 @@ const before = () => console.log(`Sending a request to the GraphQL API ...`)
 const delegate = new Delegate({ schema, before })
 ```
 
-In this example, we create a new instance of the `Delegate` class. First we take our remote endpoint and make an `HttpLink` which creates an `HTTP` transport for this binding. This means all requests to our GraphQL API are transported via `HTTP`. Next we make a `remote` schema, meaning the schema and it's API's exist on a remote server. The `before` function is unique to the `Delegate` class. Use this to execute code _prior_ to a GraphQL request.
+In this example, we create a new instance of the `Delegate` class. First we take our remote endpoint and make an `HttpLink` which creates an HTTP transport for this binding. This means all requests to our GraphQL API are transported via HTTP. Next we make a remote schema, meaning the schema and it's API's exist on a remote server. The `before` function is unique to the `Delegate` class. Use this to execute code _prior_ to a GraphQL request.
 
 ### Methods
 
@@ -93,7 +93,7 @@ In this example, we create a new instance of the `Delegate` class. First we take
 before: () => void
 ```
 
-A function that's executed _before_ a query, mutation or subscription request is sent to the API. This applies to [`request`](#request), [`delegate`](delegate) and [`delegateSubscription`](#delegateSubscription). This lets you for example modify the `link` that's used to reach the API, implement analytics features or add a logging statement before each API request.
+A function that's executed _before_ a query, mutation or subscription request is sent to the API. This applies to [`request`](#request), [`delegate`](#delegate) and [`delegateSubscription`](#delegateSubscription). This lets you for example modify the link that's used to reach the API, implement analytics features or add a logging statement before each API request.
 
 #### `request`
 
@@ -148,7 +148,7 @@ delegate(operation: QueryOrMutation, fieldName: string, args: {
   - `transforms` (optional): Allows to perform transformations on the `info` object or the `schema`.
   - `context` (optional): Allows to pass additional information to the GraphQL API that's abstracted.
 
-**Example: Hardcode the selection set as a string:**
+**Example: Hardcode the selection set as a string**
 
 ```js
 const args = { name: `Rowan` }
@@ -177,7 +177,7 @@ delegateSubscription(fieldName: string, args?: {
 }, infoOrQuery?: GraphQLResolveInfo | string, options?: Options): Promise<AsyncIterator<any>>;
 ```
 
-`delegateSubscription` allows you to [delegate](https://blog.graph.cool/graphql-schema-stitching-explained-schema-delegation-4c6caf468405) the execution of a subscription to the GraphQL API that's abstracted by this binding. This function is often used when building a GraphQL gateway layer.
+`delegateSubscription` allows you to [delegate](https://www.prisma.io/blog/graphql-schema-stitching-explained-schema-delegation-4c6caf468405/) the execution of a subscription to the GraphQL API that's abstracted by this binding. This function is often used when building a GraphQL gateway layer.
 
 ##### Properties
 
@@ -188,7 +188,7 @@ delegateSubscription(fieldName: string, args?: {
   - `transforms` (optional): Allows to perform transformations on the `info` object or the `schema`.
   - `context` (optional): Allows to pass additional information to the GraphQL API that's abstracted.
 
-**Example: Selection set based on the `info` object inside a GraphQL resolver**:
+**Example: Selection set based on the `info` object inside a GraphQL resolver**
 
 ```js
 const Subscription = {
@@ -206,7 +206,7 @@ const Subscription = {
 }
 ```
 
-> [Learn more about the `info` object.](https://blog.graph.cool/graphql-server-basics-demystifying-the-info-argument-in-graphql-resolvers-6f26249f613a)
+> [Learn more about the `info` object.](https://www.prisma.io/blog/graphql-server-basics-demystifying-the-info-argument-in-graphql-resolvers-6f26249f613a)
 
 #### `getAbstractResolvers`
 
@@ -266,16 +266,16 @@ The `Options` type has two fields:
 
 ### Transforms
 
-Schema transforms are a tool for making modified copies of GraphQLSchema objects, while preserving the possibility of delegating back to original schema.
+Schema transforms are a tool for making modified copies of `GraphQLSchema` objects, while preserving the possibility of delegating back to original schema.
 
-Transforms are useful when working with remote schemas, building GraphQL gateways, and working with GraphQL microservices.
+Transforms are useful when working with [remote schemas](https://www.prisma.io/blog/how-do-graphql-remote-schemas-work-7118237c89d7/), building GraphQL gateways, and working with GraphQL microservices.
 
 More information on `transforms` can be found [here](https://www.apollographql.com/docs/graphql-tools/schema-transforms.html)
 
 
 ### Context
 
-In GraphQL APIs, context can be provided to every resolver that holds important contextual information like the currently logged in user, or access to a database. Utilizing context is extremely crucial for bindings to GraphQL servers that may inherit context from a HTTP request or encode user-specific information to the request.
+In GraphQL APIs, `context` can be provided to every resolver that holds important contextual information like the currently logged in user, or access to a database. Utilizing `context` is extremely crucial for bindings to GraphQL servers that may inherit data from HTTP request headers or encode user-specific information to the request. You then can utilize this in each of your resolvers.
 
 In the example below we pass through context from the incoming GraphQL resolver to the underlying binding.