GraphQL

GraphQL Core: Queries, Mutations & Subscriptions #6

Deep dive into the GraphQL Queries, Mutations & Subscriptions & how to work with them

Founder @ednsquare | Continiously Designing Testing Coding at ednsquare | Any query? shoot an email at ednsquare@gmail.com

Published · Apr 6 2020

Pervious tutorial: GraphQL Schema Fields & Types - II #5

In this post, you'll learn in detail about Core concepts of GraphQL.  In this post, we will look into below concepts
GraphQL Query
GraphQL Mutation
GraphQL Subscription

  

GraphQL Query
Most types in your schema will just be normal object types, but there are special within a schema such as Query:
schema {
  query: Query 
}

That means that the GraphQL service needs to have a Query type with Person and Planet fields:
type Query {
  person(id: Int!): Person
  planet(id: Int!): Planet
}

Every GraphQL service has a query type and may or may not have a mutation type. These types are the same as a regular object type, but they are special because they define the entry point of every GraphQL query. 
{
  person (id:1) {
    name
    image
    id
    height
  }
  planet (id: 1) {
    name
    id
    gravity
    population
  }
}

It's important to remember that other than the special status of being 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.
. . .
GraphQL Mutation
Most types in your schema will just be normal object types, but there are special within a schema such as Mutation:
schema {   
  mutation: Mutation 
}

 That means that the GraphQL service needs to have a Mutation type with createPerson field:
type Mutation {
  createPerson(name: String!, age: Int!): Person
}

Mutations follow the same syntactical structure as queries, but they always need to start with the mutation keyword. Here’s an example for how we might create a new Person.
mutation {
  createPerson(name: "Bob", age: 36) {
    name
    id
    age
  }
}


. . .
GraphQL Subscription
Most types in your schema will just be normal object types, but there are special within a schema such as Subscription :
schema {   
  subscription: Subscription 
}

That means that the GraphQL service needs to have a Mutation type with newPerson field:
type Subscription {   
newPerson (): Person 
}

Subscriptions are written using the same syntax as queries and mutations. Here’s an example where we subscribe on events happening on the Person type:
subscription {
  newPerson {
    name
    age
  }
}

After a client sent this subscription to a server, a connection is opened between them. Then, whenever a new mutation is performed that creates a new Person, the server sends the information about this person over to the client:
{
  "data": {
    "newPerson": {
      "name": "Bob",
      "age": 36,
      "id": "7db71f51-2a6d-47d9-b261-879c41f293f0"
    }
  }
}

You can play around with below codesendbox to see how it works
first subscribe for new person in first tab
create a new person from another tab

once new person is created, it will be displayed on the newPerson subscription tab:


Generally, a schema is simply a collection of GraphQL types. However, when writing the schema for an API, there are some special root types:
type Query { ... } 
type Mutation { ... } 
type Subscription { ... }
. . .
In the next tutorial, we will look into Argument,  Aliases & Fragments
Up next: Arguments, Aliases & Variables #7

A Comprehensive Guide to Learn GraphQL & Its Core Concepts with examples