Applications and Advantages of GraphQL in Modern Web Applications

GraphQL is a modern API query language that is widely used in modern web applications because it provides an efficient, flexible and powerful way to obtain data

GraphQL basic quick application example:

1. Backend settings (using graphql-yoga)

First, we need to create a GraphQL server. Install graphql-yoga and create a simple GraphQL schema:

npm init -y
npm install graphql yoga graphql-yoga

# server.js
const { GraphQLServer } = require('graphql-yoga');

const typeDefs = `
  type Query {
    hello: String
  }

  type Mutation {
    addMessage(message: String!): String
  }
`;

const resolvers = {
  Query: {
    hello: () => 'Hello world!',
  },
  Mutation: {
    addMessage: (_, { message }) => `You added the message "${message}"`,
  },
};

const server = new GraphQLServer({ typeDefs, resolvers });
server.start(() => console.log(`Server is running on http://localhost:4000`));

2. Front-end setup (using Apollo Client)

Next, we need to configure Apollo Client in the front-end application to communicate with our GraphQL server:

npm install apollo-boost @apollo/client graphql

# client.js
import ApolloClient from 'apollo-boost';
import { InMemoryCache } from '@apollo/client';

const client = new ApolloClient({
  uri: 'http://localhost:4000/graphql',
  cache: new InMemoryCache(),
});

export default client;

3. Write front-end components

Now, we use Apollo Client in the React component to perform queries and mutations:

// App.js
import React from 'react';
import { gql, useQuery, useMutation } from '@apollo/client';
import client from './client';

const GET_HELLO = gql`
  query GetHello {
    hello
  }
`;

const ADD_MESSAGE_MUTATION = gql`
  mutation AddMessage($message: String!) {
    addMessage(message: $message)
  }
`;

function App() {
  const { loading, error, data } = useQuery(GET_HELLO);
  const [addMessage, { data: mutationData }] = useMutation(ADD_MESSAGE_MUTATION);

  if (loading) return <p>Loading...</p>;
  if (error) return <p>Error :(</p>;

  return (
    <div>
      <h1>{data.hello}</h1>
      <button onClick={() => addMessage({ variables: { message: 'Hello from frontend!' } })}>
        Add Message
      </button>
      {mutationData && <p>New message: {mutationData.addMessage}</p>}
    </div>
  );
}
export default App;

We create a GET_HELLO query to get the server's greeting and display it on the page. At the same time, we define an ADD_MESSAGE_MUTATION mutation operation, which will send a new message to the server when the user clicks the button.

4. Run the application

Start the backend server:

node server.js

Then start the frontend application, assuming Create React App:

npm start

GraphQL Basic Queries

1. Query Language: Queries, Mutations, Subscriptions

In GraphQL, queries and mutations are strings represented by JSON-like structures. Here is a simple example:

# Query Example
query GetUser {
  user(id: 1) {
    name
    email
  }
}

# Mutation Example
mutation CreateUser {
  createUser(name: "Alice", email: "[e-mail]") {
    id
    name
  }
}

# Subscription Example (Assuming WebSocket)
subscription OnNewUser {
  newUser {
    id
    name
  }
}

In the above code, the GetUser query requests the name and email of the user with user ID 1. The CreateUser mutation creates a new user and returns the new user's ID and name. The OnNewUser subscription waits for the new user to be created and returns the new user's information.

2. Type System

On the backend, we define a GraphQL schema to describe these types:

type User {
  id: ID!
  name: String!
  email: String!
}

type Mutation {
  createUser(name: String!, email: String!): User
}

type Subscription {
  newUser: User
}

Here we define a User object type, a Mutation type for mutation operations, and a Subscription type for subscription operations.

3. Query structure: fields and parameters

The query structure consists of fields and parameters. In the query example above, user is the field, and id and email are subfields of the user field. Parameters such as id: 1 are used to customize the query.

4. Hierarchy and nesting

GraphQL queries can be nested. Here is a more complex example:

query GetUsersAndPosts {
  users {
    id
    name
    posts {
      id
      title
      content
      author {
        id
        name
      }
    }
  }
}

This query requests all users and their respective posts, which also include information about the author. Hierarchies allow multiple levels of data to be retrieved in one request.

Client Code Example (Using Apollo Client)

import { gql, useQuery } from '@apollo/client';

const GET_USERS_AND_POSTS = gql`
  query GetUsersAndPosts {
    users {
      id
      name
      posts {
        id
        title
        content
        author {
          id
          name
        }
      }
    }
  }
`;

function App() {
  const { loading, error, data } = useQuery(GET_USERS_AND_POSTS);

  if (loading) return <p>Loading...</p>;
  if (error) return <p>Error :-(</p>;

  return (
    <div>
      {data.users.map(user => (
        <div key={user.id}>
          <h2>{user.name}</h2>
          <ul>
            {user.posts.map(post => (
              <li key={post.id}>
                <h3>{post.title}</h3>
                <p>{post.content}</p>
                <p>Author: {post.author.name}</p>
              </li>
            ))}
          </ul>
        </div>
      ))}
    </div>
  );
}

export default App;

In this React component, we use useQuery to fetch data from a GraphQL server and render information about users and their posts. This is how GraphQL queries, type systems, and hierarchies come into play.

GraphQL Schema

GraphQL Schema Definition Language (SDL) is a language for describing GraphQL schemas. It defines data types, queries, mutations, and directives in a concise, human-readable format.

Define types
First, let's define some basic data types. For example, define a User type and a Post type.

type User {
  id: ID!
  username: String!
  email: String!
  posts: [Post!]!
}

type Post {
  id: ID!
  title: String!
  content: String!
  author: User!
}

Here, the User type has id, username, email fields, and a posts field that links to multiple Posts. The Post type contains id, title, content fields, and an author field that points to the User.

Query root and mutation root
Next, define the GraphQL query root (Query) and mutation root (Mutation) types, which are the entry points for clients to request data and modify data.

type Query {
  user(id: ID!): User
  allUsers: [User!]!
  post(id: ID!): Post
  allPosts: [Post!]!
}

type Mutation {
  createUser(username: String!, email: String!): User
  createPost(title: String!, content: String!, userId: ID!): Post
}

In the Query type, we define queries for getting a single user, all users, a single post, and all posts. In the Mutation type, we define operations for creating new users and new posts.

Understanding and using Directives
Directives are instructions in the GraphQL schema that change execution behavior. They can be applied to any part of the type system definition, such as fields, input types, object types, etc. The following shows how to use a custom @auth directive to control access rights.

First, suppose we define an @auth directive to restrict access to certain fields and require users to log in.

scalar DateTime

directive @auth(requires: Role = ADMIN) on FIELD_DEFINITION

enum Role {
  ADMIN
  USER
}

Next, apply this directive in the schema:

type Query {
  me: User @auth(requires: USER)
}

type User {
  id: ID!
  username: String!
  email: String! @auth(requires: ADMIN)
  posts: [Post!]!
}

In the above example, the me query and username field can be accessed without special permissions, but accessing the user's email field requires administrator permissions (specified by the @auth(requires: ADMIN) directive).

GraphQL Advanced Applications

1. Pagination

Use GraphQL Cursor-based pagination to improve performance and user experience.

Schema definition:

type PageInfo {
  hasNextPage: Boolean!
  hasPreviousPage: Boolean!
  startCursor: String
  endCursor: String
}

extend type Query {
  users(first: Int, after: String, last: Int, before: String): [User!]!
  usersConnection(first: Int, after: String, last: Int, before: String): UserConnection!
}

type UserConnection {
  edges: [UserEdge!]!
  pageInfo: PageInfo!
}

type UserEdge {
  cursor: String!
  node: User!
}

Resolver example:

const resolvers = {
  Query: {
    users: (parent, args, context, info) => {
      // Implement logic and perform paging queries based on parameters such as args.first, args.after, etc.
    },
    usersConnection: (parent, args, context, info) => {
      // Implement logic and return UserConnection object with paging information
    },
  },
};

2. Error handling

Customize error handling to improve the client's ability to handle errors.

Resolver example:

const resolvers = {
  Mutation: {
    createUser: async (parent, args, context, info) => {
      try {
        // Creating User Logic
      } catch (error) {
        throw new Error("Failed to create user", { extensions: { code: "USER_CREATION_FAILED" } });
      }
    },
  },
};

3. Custom directives

Create custom directives to implement specific business logic or security requirements.

Schema definition:

directive @log on FIELD_DEFINITION

Resolver example:

const directiveResolvers = {
  log: (next, source, args, context, info) => {
    console.log(`Executing field: ${info.fieldName}`);
    return next();
  },
};

Make sure to register this directive handler in your GraphQL server configuration.

4. GraphQL Federation

Federation allows building a single GraphQL API composed of multiple services.

Service A Schema:

extend schema
  @link(url: "https://specs.apollo.dev/federation/v2.0", import: ["@key", "@shareable"])

type Product @key(fields: "upc") {
  upc: String! @external
  price: Float
}

Service B Schema:

extend schema
  @link(url: "https://specs.apollo.dev/federation/v2.0", import: ["@key"])

type Review {
  body: String
  author: User @provides(fields: "username")
}

extend type User @key(fields: "id") {
  id: ID! @external
  username: String
}

5. Complex query optimization

Use GraphQL's field resolver and data loader to optimize performance.

Data Loader example:

const dataLoader = new DataLoader(keys => db.batchLoadUsers(keys));

const resolvers = {
  User: {
    friends: (parent, args, context, info) => {
      return dataLoader.load(parent.id);
    },
  },
};

GraphQL Features and Advantages

• Performance optimization: By obtaining data on demand, network transmission overhead is reduced and page loading speed is improved.
• Reduce errors: The client defines the query structure, and the server returns the expected shape, reducing errors caused by interface mismatch.
• Better API design: The strong type system ensures the consistency and correctness of the data, making the API easier to understand and maintain.
• Client control: The client can decide how much data to obtain and when to obtain it, which improves the user experience.
• Cache optimization: The client can more easily implement caching strategies based on the returned data structure.
• Reduce backend complexity: The backend no longer needs to create multiple API endpoints to meet the needs of different clients.