GraphQL

Question 1

What is GraphQL?

Answer 1

GraphQL is a query language for APIs, using a type system you define for your data.

Question 2

Difference between REST API’s and GraphQL API’s?

Answer 2

While typical REST APIs require loading from multiple URLs, GraphQL APIs get all the data your app needs in a single request. + don’t have to use manual parsing code.

Question 3

How are GraphQL API’s organized?

Answer 3

GraphQL APIs are organized in terms of types and fields, not endpoints.

Question 4

What’s the command line syntax for generating a GraphQL object type?

Answer 4

rails g graphql:object ObjectName field:String field:Int field:[Comment]

Question 5

What are Types?

Answer 5

Types describe objects you can fetch in your application and what fields it has. They form the basis for GraphQL’s type system.

Question 6

What’s the syntax for declaring a Type in post_type.rb?

Answer 6

app/graphql/types/post_type.rb
module Types
class PostType < Types::BaseObject
description “A blog post”
field :id, ID, null: false
field :title, String, null: false
# fields should be queried in camel-case (this will be truncatedPreview)
field :truncated_preview, String, null: false
# Fields can return lists of other objects:
field :comments, [Types::CommentType], null: true,
# And fields can have their own descriptions:
description: “This post’s comments, or null if this post has comments disabled.”
end
end

# app/graphql/types/comment_type.rb
module Types
  class CommentType < Types::BaseObject
    field :id, ID, null: false
    field :post, PostType, null: false
  end
end

Question 7

How is a Type represented in GraphQL language?

Answer 7

type Character {
name: String!
appearsIn: [Episode!]!
}

Question 8

What are: name and appearsIn?

Answer 8

fields on the Character type. That means that name and appearsIn are the only fields that can appear in any part of a GraphQL query that operates on the Character type.

Question 9

String! (?)

Answer 9

String! means that the field is non-nullable, meaning that the GraphQL service promises to always give you a value when you query this field. In the type language, we’ll represent those with an exclamation mark.

Question 10

[Episode!]! (?)

Answer 10

[Episode!]! represents an array of Episode objects. Since it is also non-nullable, you can always expect an array (with zero or more items) when you query the appearsIn field. And since Episode! is also non-nullable, you can always expect every item of the array to be an Episode object.

Question 11

How do you define a field argument?

Answer 11

type Starship {
  id: ID!
  name: String!
  length(unit: LengthUnit = METER): Float
}

Arguments can be either required or optional. When an argument is optional, we can define a default value - if the unit argument is not passed, it will be set to METER by default.

Question 12

What are Query & Mutation Types?

Answer 12

the “entry point” into the schema, the Query and Mutation types are the same as any other GraphQL object type, and their fields work exactly the same way.

Question 13

What are the GraphQL Scalar types?

Answer 13

Int: A signed 32‐bit integer.

Float: A signed double-precision floating-point value.

String: A UTF‐8 character sequence.

Boolean: true or false.

ID: The ID scalar type represents a unique identifier, often used to refetch an object or as the key for a cache. The ID type is serialized in the same way as a String; however, defining it as an ID signifies that it is not intended to be human‐readable.

Question 14

What are Enumeration types?

Answer 14

Enums, enumeration types represent a finite set of options/values (in this case, units of length, either METER or FOOT)This allows you to:

Validate that any arguments of this type are one of the allowed values

Communicate through the type system that a field will always be one of a finite set of values

Question 15

What does an enum definition might look like in the GraphQL schema language?

Answer 15

enum Episode {
  NEWHOPE
  EMPIRE
  JEDI
}

Question 16

What are the only kinds of types you can define in GraphQL?

Answer 16

Object types, scalars, and enums

Question 17

How do you mark a type as Non-Null?

Answer 17

With an exclamation (!) mark

Question 18

What is an Interface?

Answer 18

An Interface is an abstract type that includes a certain set of fields that a type must include to implement the interface.

Question 19

What is the syntax for Interface implementation?

Answer 19

type Human implements Character {
  id: ID!
  name: String!
  friends: [Character]
  appearsIn: [Episode]!
  starships: [Starship]
  totalCredits: Int
}

Question 20

What is invalid?

myField: [String!]

Answer 20

a List of Non-Null Strings:

This means that the list itself can be null, but it can’t have any null members. For example, in JSON:

myField: null // valid
myField: [] // valid
myField: [‘a’, ‘b’] // valid
myField: [‘a’, null, ‘b’] // error

Question 21

What is invalid?

myField: [String]!

Answer 21

a Non-Null List of Strings:

This means that the list itself cannot be null, but it can contain null values:

myField: null // error
myField: [] // valid
myField: [‘a’, ‘b’] // valid
myField: [‘a’, null, ‘b’] // valid

Question 22

When is Interface useful?

Answer 22

Interfaces are useful when you want to return an object or set of objects, but those might be of several different types.

Question 23

What are Union types?

Answer 23

Union types are very similar to interfaces, but they don’t get to specify any common fields between the types.

union SearchResult = Human | Droid | Starship

Question 24

How do you query a field on a Union type?

Answer 24

you need to use a conditional fragment to be able to query any fields at all:

{
  search(text: "an") {
    \_\_typename
    ... on Human {
      name
      height
    }
    ... on Droid {
      name
      primaryFunction
    }
    ... on Starship {
      name
      length
    }
  }
}

Question 25

In the GraphQL schema language, how do input types look?

Answer 25

input ReviewInput {
stars: Int!
commentary: String
}

Question 26

Input types allow you to pass what kind of arguments in a field?

Answer 26

In the case of mutations, you can pass in a whole object to be created.

Question 27

What are Aliases?

Answer 27

Allow you to query for the same field with different arguments. They let you rename the result of a field to anything you want.

{
  empireHero: hero(episode: EMPIRE) {
    name
  }
  jediHero: hero(episode: JEDI) {
    name
  }
}

> > > > > >

{
  "data": {
    "empireHero": {
      "name": "Luke Skywalker"
    },
    "jediHero": {
      "name": "R2-D2"
    }
  }
}

Question 28

What are Fragments?

Answer 28

Fragments are reusable units called fragments that let you construct sets of fields, and then include them in queries where you need to.

{
  leftComparison: hero(episode: EMPIRE) {
    ...comparisonFields
  }
  rightComparison: hero(episode: JEDI) {
    ...comparisonFields
  }
}

fragment comparisonFields on Character {
  name
  appearsIn
  friends {
    name
  }
}

Question 29

How do you pass a dynamic argument into a query?

Answer 29

Variables.

Replace the static value in the query with $variableName

Declare $variableName as one of the variables accepted by the query

Pass variableName: value in the separate, transport-specific (usually JSON) variables dictionary

query HeroNameAndFriends($episode: Episode) {
  hero(episode: $episode) {
    name
    friends {
      name
    }
  }
}