GraphQL

Question 1

How does GraphQL define the schema of an API?

Answer 1

GraphQL has its own TYPE SYSTEM that’s used to define the schema of an API: Schema Definition Language (SDL)

Question 2

What does SDL look like?

Answer 2

type Person {
name: String!
age: Int!
}

(Person has 2 fields with types, both are required)

Question 3

How do you indicate a relationship between types?

Answer 3

Associate a type with another type. If it is a one to many relationship, the many side will be an array, e.g. [Person]

Question 4

Sample query to get names of all Persons

Answer 4

{
  allPersons {
    name
  }
}

Question 5

What are the 2 parts of a query?

Answer 5

The root field and the payload. Root field is ‘allPersons’ and payload is everything after that.

Question 6

Explain query parameters

Answer 6

Each field can have zero or more arguments if that’s specified in the schema. E.g. allPersons(last:2) will limit results to last 2

Question 7

How do you change what is stored in the DB?

Answer 7

Using mutations: create, update, delete.

Question 8

How do you write a mutation?

Answer 8

Same as a query, but precede it with 'mutation':
mutation {
  createPerson(name: "Bob", age: 36) {
    name
    age
  }
}

the root field takes 2 arguments. The payload is optional, or you could ask for the autogenerated ID instead.

Question 9

What is a subscription?

Answer 9

Unlike the request-response-cycle in queries and mutations, subscriptions initiate and hold a steady connection to the server, and stream the requested data to the client when it becomes available.

Question 10

How do you create a subscription?

Answer 10

Same as a mutation.
subscription {
  newPerson {
    name
    age
  }
}
whenever anyone creates a new person, the client will get their name and age.

Question 11

What is does a schema do?

Answer 11

It specifies the capabilities of the API and defines how clients can request the data. It is often seen as a contract between the server and client. Basically, it is a collection of types.

Question 12

How do you write a schema?

Answer 12

Start with TYPES. These are the entry points:
type Query { … }
type Mutation { … }
type Subscription { … }

Question 13

In your schema, enable an allPersons query that allows the client to specify the last number of entries.

Answer 13

type Query {
allPersons(last: Int): [Person!]!
}

allPersons is the ROOT FIELD
(last:int) is the argument
[Person!]! is the the return type

Question 14

In your schema, enable a mutation that allows the client to create a new person

Answer 14

type Mutation {
createPerson(name: String!, age: Int!): Person!
}

Question 15

In your schema, enable a subscription that allows the client to receive a new person

Answer 15

type Subscription {
newPerson: Person!
}

Question 16

True or false: GraphQL can only be used with HTTP

Answer 16

False. GraphQL is actually transport-layer agnostic. It is possible to implement a GraphQL server based on TCP, WebSockets, etc.

Question 17

What kind of DB do you have to use with GraphQL?

Answer 17

Any database, any format. SQL or NoSQL.

Question 18

How do you use GraphQL with existing microservices, DBs, third party APIs, etc?

Answer 18

You can use one GraphQL server as the facade that integrates with all the other services, allowing you to hide the complexity.

Question 19

How does GraphQL handle a query (or mutation)?

Answer 19

Using resolver functions to fetch the data for each field in the query/mutation.

Question 20

How many resolver functions can a field correspond to?

Answer 20

Exactly one.

Question 21

What is contract-first design in API specification?

Answer 21

You specify the client’s data requirements upfront (e.g. Swagger, OpenAPI). This can be hard because you develop an understanding of the client’s requirements over time.

Question 22

How does GraphQL address the problem of contract-first design?

Answer 22

Push all decisions about what gets fetched to the client. Schema-first design. The schema is the contract with all the data and operations it offers.