graphql.tar.gz

graphqlspa

graphqlcodewidget

In this course, you will learn what exactly GraphQL is, how to design a robust and scalable API with it, and how to implement it in NodeJS.

You’ll start by running through the pros and cons of GraphQL in order to get a feel for its limitations and what its applications are. You’ll then take a brief look into the REST vs GraphQL debate and understand the reasons for and against both.

In the latter half of the course, you’ll explore things like GraphQL types, schemas, and mutations. In the last few sections, you’ll take what you’ve learned and make a GraphQL API in Node while scaling it for consistency.

Up and running with Node and GraphQL

# Introducing types

No matter what implementation of GraphQL you use, the way its API is expressed is via the types that make up the `schema`, which is the blueprint that makes up a GraphQL API.

A GraphQL schema is nearly always written in **Schema Definition Language** (SDL). As noted in the GraphQL Documentation, this is a way of representing the structure of your API without worrying about language-specific syntax.

To write your schema, you need to understand the types that make up a schema.

# Types vs fields

The majority of entities in a GraphQL schema are made up of `types` and `fields`. These are fairly straightforward to understand:

A type is a _thing_. On its own, it’s not that interesting. We are more interested in their contents, which are represented by _fields_.

Consider this example:

```graphql
type User {
   id: String!
   email: String!
   name: String
}
```

Here we can see the type `User`. That `User` type contains several fields. Namely, `id`, `email`, and `name`.

Most of this is quite easy to read and understand. But what about the `!` after `String`? This means that the field is non-nullable. GraphQL is saying that it will _always_ return a value when you query this field.

As for `String` iitself? This was not created by you. Instead, this is a `scalar`. GraphQL has a [number of built-in scalars](https://graphql.org/learn/schema/#scalar-types) that represent a concrete data type. Some of the scalars in GraphQL are:

- `String`
- `Int`
- `Boolean` 

The great thing about fields is that, instead of only scalars, they can also return types. This allows you to write the powerful nested queries that you may have seen before. Like this:

```graphql
query {
   listUsers { 
    id
    email
    name
    photos {
        url
    }
   }
}
```

In this example, you can see that we are running a query called `listUsers`, which then provides several `fields` for the `User` _type_.

We can also access the user's photos by providing it as a field. GraphQL is intelligent enough to understand the relationships between types when they are specified in the schema.

For reference, a user might be structured like this in the GraphQL schema:

```graphql

type Query {
listUsers: [User] # Return a list of users
}

type User {
    id: String!
    email: String!
    name: String
    photos: [Image] # Return items contained in the `Image` type.
}

type Image {
    url: String!
}
```

## Recap

So as you can see, it is fairly straightforward to get started writing a schema. With that said, writing a robust and scalable schema is much harder. This is something we will discuss later on.

For now, it's worth remembering:

- A GraphQL schema is made up of _types_ and _fields_
- A _field_ can refer to a _type_ like in our `photos` field in the example above
- A field can be one of the built-in scalars, a custom scalar, or a type
- `!` denotes a non-nullable field
- `[]` means that an array will be returned

Congratulations! You can now read the basics of a schema in GraphQL.



Learn how GraphQL is made up of types, and how they come together to make up the GraphQL schema.

__default

How GraphQL Types Work

Introducing types

Types vs fields