REST 与数据库作为 GraphQL API 数据源？

Question

We are starting a new full stack project. It has been decided we are going to use React for the front end which should consume a GraphQL API.

We are contemplating two scenarios for the development of this API:

• The first one is to build a GraphQL API that uses a REST API as data source using Apollo.

• The second one is to build a GraphQL API that uses a database as data source skipping the REST API.

What are the advantages and disadvantages of each scenario? Is one better than the other?

Answer 1

Based on our discussion on gitter,

Since you are building your platform from scratch, you don't need to build your GraphQL layer over REST APIs. That will be double work and is not needed. I recommend that you set up Apollo-Server which will directly interact with your database(s).

You said that you might need to use some legacy APIs for which I recommended Microservices which can easily work with graphql.

Regarding PRISMA, it doesn't give you as much flexibility. It also does not allow ACID compliant updates for fields such as increment or decrement a value. This issue on github can be used to track updates on this feature.

PRISMA is good for getting you set up quickly but I(personal opinion) feel that it is not as flexible.

Your final question was how do you query database/databases without REST API, for which I suggested querying directly from your server.

GraphQL is client side and Apollo will help you to extend it and provide much more features. You don't need to do things much different than what you'd do when creating a REST API other than the fact that you don't need to define separate endpoints for each request. The database interactions remain almost the same other than the fact that you only return/query for the data that you need and this can be done dynamically. From graphql website

Send a GraphQL query to your API and get exactly what you need, nothing more and nothing less. GraphQL queries always return predictable results. Apps using GraphQL are fast and stable because they control the data they get, not the server.

Other mentions: AWS Appsync

Answer 2

The second scenario is best

The second one is to build a GraphQL API that uses a database as data source skipping the REST API.

REST and GraphQL can both be operated over HTTP, though GraphQL is protocol agnostic. And GraphQL is the new kid in the block with lot of cool features and it solves most of the problem faced with REST like:

1.) Multiple end points to fetch data

In rest we have create multiple API endpoints

2.) Over/Under Fetching

Some time API return extra data that we don't need or less data in response

3.) Network Requests

multiple endpoint leads to more network requests 

4.) Error Handling

Error handling in REST is pretty straightforward, we simply check the HTTP headers to get the status of a response. Depending on the HTTP status code ( 404, 503, 500 etc) we get, we can easily tell what the error is and how to go about resolving it. GraphQL on the other hand, when operated over HTTP, we will always get a 200 OK response status. When an error occurs while processing GraphQL queries, the complete error message is sent to the client with the response

5.) Versioning

Often when consuming third-party REST APIs, we see stuff like v1, v2, v3 etc. which simply indicate the version of the REST API we are using. This leads to code redundancy and less maintainable code. With GraphQL, there is no need for versioning as we can easily add new fields and types to our GraphQL API without impacting existing queries. Also, we can easily mark fields as deprecated and the fields will be excluded from the response gotten from the server

For detailed comparison please visit GraphQl vs Rest

or this post

Or Official GraphQL site

Answer 3

Using REST to power your GraphQL is like using a to power your Tesla. Simply dumb,. Use a database but only select the fields and records asked by GraphQL query. NOT "select *". Use Redis cache if you need the speed.

Answer 4

REST is a software architecture that defines a set of constraints to be used for creating web services, Introduced in the year 2000. Whereas GraphQL is a data query and manipulation language for APIs, and runtime to fulfill queries with existing data, developed by Facebook in 2011.

Drawbacks of REST API?

The problem with REST APIs is they have multiple endpoints. These require round-trips to get the data. Every endpoint represents a resource, If we need data from multiple resources, It requires multiple round-trips to get the data. The language needed to request is very limited in the REST API.

In REST there is a problem of over-fetching, for example: If a client wants to select a specific record in the resource, the REST API will always fetch all of the fields irrespective of the client's needs. It is over usage of network and memory resources but both client-side as well as server-side

Advantages of Graphql over REST

Resolves over-fetching and under-fetching Apps Using REST APIs results in over-fetching as well as under-fetching because of the entire data in that endpoint will be returned in the JSON format. This causes performance and scalability issues.

Whereas GraphQL with its queries, schemas, and resolvers enable developers to design API call only specific data requirement, This resolves Over-fetching and Under-fetching challenges.

Faster product Iterations on the frontend When designing REST APIs, It can be a bottleneck when it comes to faster or quick iterations on the frontend. The reason behind this is because of REST APIs design endpoints according to the views in the application.

With GraphQL, Developers can write queries specifying their data requirement, and the iterations for developing frontend can continue without having to change the backend

GraphQL enables better analytics on the backend Apps that use REST APIs get entire data in an endpoint, using this application owner can't gain insights on the usage of specific data elements since the entire data is returned every time.

On the other hand, GraphQL uses resolvers, and they implement particular fields in a type. That way Application owner can track the performance of the resolvers, and find out whether the systems need performance tuning.

The Advantages of the GraphQL schema GraphQL uses Schema Definition Language (SDL), The schema includes all the types used in an API, It defines how a client should access data on the server. After defining schema by the developers, Both the front and backend teams work parallel as they know the structure of the data. This helps to improve the productivity of the team.

GraphQL proves to be very useful where it comes to fetching data that satisfies the given condition. Example:- Instead of requesting all the students in the school, you can specifically ask for the students of a particular batch.

Full Article: GraphQL vs. REST: A Detailed Comparison.