Prinzipien des GraphQL-API-Designs

Welcome to GraphQL API Design! GraphQL is a powerful query language for your APIs and a runtime for fulfilling those queries with your existing data.

Think of it as a way for clients (like your mobile app) to ask for exactly the data they need, no more, no less. It's an alternative to traditional REST APIs.

While REST APIs typically have multiple endpoints, each returning a fixed data structure, GraphQL uses a single endpoint.

• REST: Often leads to over-fetching (getting more data than needed) or under-fetching (needing multiple requests for related data).
• GraphQL: Solves this by allowing clients to specify the data shape, reducing network requests and improving efficiency.

At the heart of every GraphQL API is its schema. The schema defines the entire API's capabilities: what data can be queried, what data can be modified, and what types of data exist.

It acts as a contract between the client and the server, ensuring both sides understand the available operations and data structures.

GraphQL schemas are written using the Schema Definition Language (SDL). It's a simple, intuitive language for defining types and operations.

Let's look at a basic example of defining a User type with some fields:

In the previous example:

• type User: Defines a new object type named User.
• id: ID!: id is a field of type ID. The ! means it's non-nullable (always present).
• String, Int, ID: These are scalar types, GraphQL's built-in basic data types.
• You can also define custom object types like Post or Comment.

The Query root type is special. It defines all the entry points for reading data from your API. Think of these as the 'GET' operations in REST.

Here's how you might add operations to fetch users or a single user by ID:

Once the Query type is defined, clients can request data. They specify which fields they want from the available operations. This is how you avoid over-fetching!

To get all user names and IDs:

The Mutation root type defines all the entry points for writing or changing data in your API. These are like 'POST', 'PUT', 'PATCH', and 'DELETE' operations in REST.

Mutations often take input arguments and return the modified object.

Similar to queries, clients send mutations to perform data modifications. They specify the mutation name, its arguments, and what fields of the result they want back.

Here's an example to create a new user:

Consider the following GraphQL schema snippet. Which statements about it are TRUE?

type Book {
  id: ID!
  title: String!
  author: Author!
}

type Author {
  id: ID!
  name: String!
  books: [Book!]
}

type Query {
  books: [Book!]!
  book(id: ID!): Book
  authors: [Author!]!
}

type Mutation {
  createBook(title: String!, authorId: ID!): Book!
}

Great job! You've learned the core principles of GraphQL API design:

• GraphQL allows clients to request specific data.
• The Schema Definition Language (SDL) defines the API's contract.
• Object types define data structures.
• The Query root type handles data fetching.
• The Mutation root type handles data modification.

Next, we'll dive into building a GraphQL server with Apollo to bring these designs to life!