GraphQL allows retrieving multiple resources in a single request

REST allows performing complex queries on databases

GraphQL is faster than REST

REST is only compatible with JavaScript

A representation of the database

A configuration file for queries

The definition of data types, queries, and mutations

A description of business logic

Types that can contain multiple sub-types

Basic types like String, Int, Float, Boolean, and ID

Types that define resolution functions

Types specific to mutations

Use graphql-tools to generate a schema based on YAML files.

Define a schema using typeDefs that represent types, queries, and mutations, then associate it with resolvers.

Use JSON files to describe the types.

Define schemas only with simple JavaScript objects.

An object containing data

A function that resolves the values of a field in a query

A file that defines the structure of the schema

A means of filtering data in the database

It is a function that resolves user queries in the application.

It is a function that generates schemas for REST APIs.

It is a function that associates a field of a GraphQL type with a data source, often a database or an external service.

It is a function that performs calculations on the data sent by the user.

The Query and Mutation types in the schema must have corresponding keys in the resolvers object

The resolvers object can contain a maximum of 10 resolver functions

The names of the resolver functions must match the names of the fields in the schema

The resolver functions can have any name

A tree that defines the schema of data types

A tree representation of the structure of a GraphQL query after it has been validated

A tool for generating Apollo server code

A list of data that will be sent to the GraphQL server

Modify data on the server

Retrieve data from the server

Add data to the database

Manage authentication and permissions

An XML file

A JSON tree representing the structure of the query and data

A string with SQL instructions

A binary file

It checks the syntax of the query to ensure that the fields are correctly defined

It executes the requested mutation

It optimizes the queries for the server

It converts the data to JSON before sending it

An HTTP error message

An object data with a null value and an array errors

A redirection to an error page

No response, the error is directly handled by the client

A data reading operation

A data modification or addition operation

A data reading operation

A data modification or addition operation

A data deletion operation

An operation to obtain multiple resources in a single request

Apollo Server continues the execution of the mutation and ignores the error

Apollo Server cancels the mutation and returns an error in the response

Apollo Server returns an HTTP 404 error

Apollo Server redirects to an error page

The error is returned in the errors field of the response

The error blocks the transaction and is not returned

The error is logged in a log file but the mutation continues

The mutation is ignored and no data is returned

It is an abstraction for making SQL queries directly

A DataSource is a mechanism for retrieving data from different sources (REST APIs, databases, etc.)

It is a type of mutation for sending data to an external API

A DataSource is a local cache for storing GraphQL responses

By using ApolloDataSource as a base class

By calling an external REST service on each request

By creating a datasource.js file that contains a data object

By using a schema file to define resolvers

They allow centralizing error management logic

They handle caching to avoid making multiple identical requests

They manage the security of API calls

They simplify the creation of GraphQL schemas

get(), post(), put(), delete()

fetch(), query(), update(), remove()

query(), mutate(), subscribe()

add(), remove(), update(), fetch()

It helps to resolve a query that has been made for the first time much more quickly.

It helps to manage the mixing of different endpoints with different caching policies.

It helps to resolve more quickly the fields of queries that have already been retrieved.

It prevents unnecessary REST API calls for data that is not frequently updated.

It executes it immediately on the database

It compiles it into JavaScript code

It validates it to ensure it complies with the schema and GraphQL rules

It caches it in the local cache before resolving it

The request is malformed or contains syntax errors

The data returned by the request is not valid

The user is not authorized to execute the request

The server failed to connect to the database

It only sends HTTP error codes

It captures them and returns them in an errors object in the response

It redirects the user to an error page

It automatically retries the request in case of an error

{ data: { mutationName: result } }

{ mutationName: result }

{ success: true, data: result }

{ status: 'success', data: result }

It directly executes SQL queries

It resolves the fields of queries using "resolvers"

It sends the queries to an external server

It compiles the queries into JavaScript

It returns an object with errors and the modified data

It continues the execution of the mutation despite the error

It cancels all ongoing mutations

It returns only an error message without data

Manage the database

Serve GraphQL queries to a server

Manage local state and GraphQL queries from the client

Handle mutations and subscriptions

It hides them to avoid repeating errors

It sends a notification to the user

It passes them as error objects in the response

It stops the execution of any other request

It uses real-time queries

It caches responses and uses the cache to avoid repeated queries

It compresses data before sending it to the server

It allows parallel execution of queries

Apollo Client never caches the results.

Apollo Client uses an in-memory cache to store the responses of queries and reuse them to avoid making network requests again.

Apollo Client stores all data in the browser's local storage.

Apollo Client only caches the results of mutations.

The useQuery hook returns an array, while the useMutation hook returns an object

The useQuery hook returns an object, while the useMutation hook returns an array

The useQuery hook is used to send queries, while the useMutation hook is used to send mutations

The useQuery hook executes automatically on component render, while the useMutation hook returns a mutate function that must be called to trigger the mutation

Provide the instance of Apollo Client to the entire React application

Initialize Apollo Server

Manage mutations

Define the GraphQL schema

ApolloProvider initializes Apollo Server.

ApolloProvider allows the React application to communicate with the Apollo server.

ApolloProvider is used to handle errors in GraphQL queries.

ApolloProvider is used to add mutations to the schema.

A "query hook" allows you to execute POST type requests in the React component.

A "query hook" allows you to execute GraphQL queries and manage loading, error, and data states.

A "query hook" allows you to synchronize data between multiple React components.

A "query hook" is a way to manage server-side caching.

Provide an IDE for writing Apollo code

Offer an interface to manage and monitor GraphQL APIs

Automatically create GraphQL schemas

Deploy Node.js applications

The structure of the GraphQL schema

The history of HTTP requests

The server logs

User statistics