Since its public release in 2015, GraphQL has been on the rise both in popularity and widespread use. The addition of the data graph changed the development process forever, bringing together data and services in a comprehensive and secure way. An ever-growing number of companies have recognized its vast capabilities, with such entities as Shopify, Microsoft or Yelp adding GraphQL to their development stacks.

GraphQL is alive and well, but how did it grow from a hermetic language used by very few to a widely recognized, almost indispensable tool? It wouldn't be here without quite a few success stories surrounding it.

A perfect example would be a recent migration of Airbnb's API. It has been discussed at length by [Brie Bunge, one of their software engineers, at GraphQL summit](https://www.youtube.com/watch?v=pywcFELoU8E\&feature=youtu.be), where she described the process in some detail. I wanted to take a look at some of the distinct advantages of using GraphQL in these operations in the hope that you, dear reader, might find a solution to one of your problems.

![Migrating from REST to GraphQL](https://graphqleditorcms.fra1.cdn.digitaloceanspaces.com/graphqleditorcms/blogpost/graphql-restapi.webp)

##### Source: [undraw.co](https://undraw.co/)

## Better data access

The adoption of GraphQL for their API resulted in quicker access to data and a much more enjoyable interface. Thanks to the step-by-step approach to migration, with hardly any downtime during the whole process. Instead of trying to convert preexisting code at once or even rebuilding from the ground up, Airbnb opted for gradual changes. Consequently, this allowed for a smooth transition without the need to put any services on pause.

## Over-fetching problem

Another improvement gained through switching over to [GraphQL](https://graphqleditor.com/) was the significant reduction in over-fetching. The data has been shaped in a way that doesn’t allow for requesting any more than is needed in a particular instance. This severely reduces unnecessary costs that may have been incurred beforehand, something that must be considered when designing data architecture.

After the whole conversion process was complete, the result was a dependable, streamlined and far-reaching tool. It is able to quickly and reliably access requested data by combining the strengths of its components while getting rid of needlessly complicated code. Furthermore, should the need arise, Airbnb’s implementation of GraphQL is ready to be scaled within reason. According to [Adam Neary](https://medium.com/@AdamRNeary), another software engineer at the aforementioned company, other benefits [include](https://medium.com/airbnb-engineering/reconciling-graphql-and-thrift-at-airbnb-a97e8d290712):

* a strongly typed API schema,
* flexibility in field selection,
* cross-platform client-side development

... and many more.

Despite the indisputable gains from using [GraphQL](https://graphqleditor.com/), this project is far from complete. There are numerous improvements that can be developed sooner or later.

By reshaping the schema into a more data-centric one, they hope to cut down on duplicate requests, further increasing the efficiency and speeding up the caching, which has been a major bottleneck up till then.

This is but one of many examples of GraphQL being a prime choice for data handling at a major company. Nearly a thousand businesses from various branches using this language for all their dealings with queries, showing just how flexible and efficient it is.

The advantages of migrating to GraphQL

Another piece of great news for the GraphQL community surfaced last week. A San Francisco-based startup **Hasura Inc. announced a $9.9M Series A investment!**

Originally **Hasura** was a company aiming to help developers to simplify Kubernetes, but over time the team has realized that there was a much bigger problem they could address - data access.

Application developers need better access to data sitting in databases.  The Hasura team wants to solve that issue with the help of **GraphQL**, so they have pivoted into an open-source service that takes your databases & with a little bit of configuration allows you to deploy a production-ready GraphQL backend.

![](https://graphqleditorcms.fra1.cdn.digitaloceanspaces.com/graphqleditorcms/media/hasura-1730752491690.webp)

##### Source: [hasura.io](https://hasura.io/)

Hasura's software downloads count is soon going to hit a stunning **30 million**! Its open-source software is used by the thousands of development teams in the biggest wide variety of industries including aerospace and healthcare.

The new funding would let the company raise its headcount which currently oscillates around 40 employees. This would allow them to scale the number of supported database types as well as prepare for the launch of its new enterprise version which should appear on the market this year. As mentioned on [Hasura's GraphQL blog](https://hasura.io/blog/hasura-2020-the-next-phase-of-our-journey/) the biggest goals on their road map as for now are:

* Serve the needs of their production & enterprise users on a level better than ever before
* Deliver the GraphQL features that the Hasura community wants
* Expand the Hasura experience to other databases
* Invest in Hasura community

***

### Keep up doing a great job, congrats to Hasura team! :)

***

Hasura lands a $9.9M to simplify GraphQL development

One of the core notions of using [GraphQL](https://graphqleditor.com/) is a schema. It strictly defines the potential an API might have by forming a set of concepts and relations between them. Another crucial function of a schema is regulating how and by using which action data can be accessed.

Designing a schema is one of the first steps in the development process, casting a shadow over the following tasks. Due to how many areas are affected by a schema, later on, its architecture should be carefully planned. This, hopefully, leads to a naturally evolving, intuitive, and most importantly secure product.

[![GraphQL Schema](https://graphqleditorcms.fra1.cdn.digitaloceanspaces.com/graphqleditorcms/blogpost/schema-1730849614480.webp)](https://graphqleditor.com/)

##### Source: [undraw.co](https://undraw.co/)

## Scaling

Attempting to adjust a project which wasn't designed with greater scope in mind can be quite a headache. Adding something which seems inconspicuous to the end-user may involve a long list of tedious tasks. Deprecating pre-existing concepts, adding new ones only to be renamed a while later, keeping track of what has and what has not been yet modified. This process only gets more complex with every such change required. This can be avoided by following a few simple rules in scalable schema design.

[![Scaling schema-based project is easier](https://graphqleditorcms.fra1.cdn.digitaloceanspaces.com/graphqleditorcms/blogpost/scale-1730849610896.webp)](https://graphqleditor.com/)

##### Source: [undraw.co](https://undraw.co/)

##### Keep it simple

The goal of using [GraphQL is to create something transparent](https://graphqleditor.com/blog/what-offers-graphql-api/), easy to understand for everyone involved. However, this is made impossible if a schema can be compared to a labyrinth of connections and sources of data. Think about the developer who comes after you have moved on to other projects. An example of good practices can be using input object type for mutations.

##### Force yourself to be adaptable

To avoid the aforementioned headache in scaling, a schema should be easily adjusted to specific, often unforeseen, requirements. It is often the case that many concepts must be deprecated at once, whereas other ones need to be added without breaking the rest. A good way of doing this is using the tools given by [GraphQL](https://graphql.org/) itself, as opposed to creating one's own. Custom-made tends to be more convenient at the time, but it is less comprehensive looking from the outside.

##### Be creative & specific

Being a little bit more creative when designing a schema tends to pay off in the long run. Instead of going for the easy way out and using something generic, make the type name more specific. When in doubt, consult other people involved in the project, they may have some interesting ideas about how and for what reason you should name a concept in a certain way.

## Security

Carelessly drawn-up schemas may create various possibilities for malicious attacks in different ways. An example of such behavior is exposing data in unanticipated ways.

![Schema security is a crucial issue](https://graphqleditorcms.fra1.cdn.digitaloceanspaces.com/graphqleditorcms/blogpost/security-1730849617496.webp)

##### Source: [undraw.co](https://undraw.co/)

##### Think about proper pagination

One of the preventative measures can be proper pagination. This is a feature which is not provided by the language itself, it is mostly left to the imagination of the developer. There are many different ways in which pagination can be implemented, which makes the choice that more difficult. It is imperative to take into account the needs of the project, rather than personal preference.

##### Don't overload the client-side

Allowing the clients to manipulate data is generally frowned upon since it can give birth to a multitude of issues. It is a much better idea to keep as much as possible server-side, most preferably batched in a single large request, as opposed to multiple small ones. This has a two-pronged effect: reduces the amount of data that needs to be repeatedly loaded, and simplifies the result for the end-user.

Do not leave schema design to chance. Make it a group project, spend a couple of sessions together, brainstorming ideas and collaborating with everyone who has something to do with all the data. Hopefully, this leads to a good schema:

* one that is functional,
* malleable and easy to understand.

Future you will surely thank you later.

***

* A guest blog post for [GraphQL Editor blog](https://graphqleditor.com/blog/) by Carl Matte;
  Sources: [Do’s & Don’ts for your schema and GraphQL operations](https://www.youtube.com/watch?v=fG8zy1OROp4), [atheros.ai](https://learning.atheros.ai/blog/graphql-best-practices-for-graphql-schema-design), [apollographql.com](https://www.apollographql.com/blog/backend/schema-design/graphql-building-evolvable-schemas)

How a well-planned schema can change your project?



A while ago **MongoDB announced GraphQL integration** in one of their products. It's a piece of huge news & another token of recognition for GraphQL. MongoDB team sees a great opportunity in this integration as they believe to not having to create a custom backend implementation of GraphQL can save thousands of development teams a lot of effort and resources. GraphQL support was launched for MongoDB Atlas, as integration with **MongoDB Stitch** which acts as both the GraphQL client and server.


![MongoDB + GraphQL](/mongo_graphql.webp)

## What's GraphQL

**GraphQL is a data query language** that offers a declarative query ability via API comparing to typical REST API implementation, which returns a full payload of information. 

Some of the GraphQL benefits include:

- **smaller payloads** as it uses types to make sure client ask only for data that can be returned,
- **better performance on slower connections** thanks to a reduced number of bits transferred over the wire,
- **quicker MVP builds** as GraphQL provides a single endpoint for flexible & more efficient data access & management.



## GraphQL + MongoDB Stitch

**MongoDB Stitch** is the serverless platform offered by MongoDB. As for every serverless, its main premise is:


> *Write less code and build apps faster*

and the way of achieving this is to write less code (obviously) by using all the good stuff (**now also GraphQL!**) offered by **Stitch SDK** like authentication, access rules, MongoDB queries, services, functions & more.

```ts
// Install with npm:// npm install mongodb-stitch
// Then simply add the Stitch SDK to your application

import {
  Stitch,
  AnonymousCredential,
  RemoteMongoClient
} from 'mongodb-stitch-browser-sdk'

// 1. Connect to MongoDB
// It’s simple to point Stitch to a MongoDB collection
const stitchClient = Stitch.initializeDefaultAppClient('myApp');

// Connect to a MongoDB Atlas database
const db = stitchClient
  .getServiceClient(RemoteMongoClient.factory, 'mongodb-atlas')
  .db('production');

 // Anonymously authenticate, then add and retrieve documents.
stitchClient.auth.loginWithCredential(new AnonymousCredential())
  .then(() =>
    db.collection('items').insertOne({
      owner_id: stitchClient.auth.user.id,
      number: 42
    })
  ).then(() =>
    db.collection("items").find({}).asArray()
  ).then((docs) =>
    docs.forEach((doc, index) =>
      console.log(`${index}: ${JSON.stringify(doc)}`)
    )
  );
```
##### Source: [mongodb.com](https://www.mongodb.com/cloud/stitch)

If you want to play with Stitch SDK & GraphQL make sure to check out the official [introduction to GraphQL support in MongoDB](https://www.mongodb.com/blog/post/introducing-graphql-support-in-mongodb-atlas-with-stitch) where you will find:

- a step by step setup guide 
- an overview of new GraphQL related features in Stitch Dashboard (i.e. integrated **[GraphiQL](/graphql-playground) interface**)
- as well as some cool examples projects

![MongoDB Stitch's integrated [GraphiQL](/graphql-playground) Interface](/mongo_graphiql.webp)





MongoDB announced GraphQL integration

Whether weaved into an already existing application, or included as an integral part of an application's architecture from day one, an API is a powerful tool in a developer's arsenal. When properly implemented, it can be quite an important factor when it comes to designing the user experience, communicating between software components and providing the building blocks themselves.

However, an unsatisfactory API may become more of a curse rather than a blessing:

* it can drive up the costs,
* case security problems,
* raise project’s complexity & deteriorate the ease of use in general

Let’s take a look at ways in which GraphQL can help avoid some of the pitfalls of making an API.

### Schema as a source of truth

If not carefully planned out, an API architecture can start bleeding money by ever-increasing management and infrastructure costs. GraphQL tackles this problem by forcing its developer to prepare a clearly defined schema ([GraphQL Editor comes in handy](https://graphqleditor.com/)) and, at the same time, limiting the amount of data returned specifically to the requested scope. Designing a schema should incorporate various ideas from a multitude of people working on or with the API in order to create a broad scope of possible use-cases. Due to the fact that schemas naturally evolve by deprecating some fields and adding new ones, this makes GraphQL an elegant answer to swollen, cumbersome APIs. The previously mentioned narrowing of data returns solves the common issue of over-fetching.

### GraphQL makes it simpler

Another cause for a headache that a potential developer might encounter is excessive complexity combined with convoluted documentation. It is of the utmost importance to know how something behaves in certain conditions and why it works in a particular way. This is made nearly impossible, or at least not cost-effective, if the developer cannot find the answers that are sought in the documentation surrounding an API. GraphQL, having been adopted by many communities around the programming world, has the benefit of a continuously growing and largely active developer base. This greatly enhances the experience a potential engineer might have as it makes finding the right tools for the job quite simple.

### Security

Security needs to be taken into consideration. It is quite likely that an API can be explored by certain individuals as a possible gateway to extracting sensitive data or harming the application in other ways. Allowing such malicious attacks to affect the intended user can really tarnish one’s reputation as a reliable programmer. Although GraphQL allows for limiting the scope of possible queries to a prearranged whitelist, there are other, more flexible ways of handling the problem. Setting a cap on how many requests can be made in any given period of time is a common preventative measure for DDoS attacks.

![GraphQL Security](https://graphqleditorcms.fra1.cdn.digitaloceanspaces.com/graphqleditorcms/blogpost/security-1730848290879.webp)

##### Source: [undraw.co](https://undraw.co/)

### Conclusion

The very nature of GraphQL appears to solve many of the issues plaguing a plethora of other APIs. Furthermore, should any other problems arise, they will have surely been already tackled by the rich and vibrant community which surrounds this query language. These factors combined make GraphQL a very appealing option when considering implementing an API.

##### Sources:

##### [MarvelApp.com](https://marvelapp.com/blog/why-marvel-uses-graphql/)

##### [Netlify.com](https://www.netlify.com/blog/2020/01/21/advice-from-a-graphql-expert/)

##### [Devops.com](https://devops.com/challenges-of-designing-api-driven-experiences/)

What can GraphQL do for your API?

We are digital explores. We love to work on cutting-edge technologies & new frameworks. That's a fact. [GraphQL](https://graphql.org/) is definitely one of those but when it comes to implementing new tech in commercial projects you need to convince your team or Lead Developer that it's worth giving a shot.

How to do it? It obviously not that easy. First of all, you need to explain what exactly is GraphQL and how your project would benefit from it. Then you need to answer some questions ... a lot of questions!

![](https://graphqleditorcms.fra1.cdn.digitaloceanspaces.com/graphqleditorcms/media/conv-me-1730828603636.webp)

## Let's begin with "What's GraphQL?" part...

#### What's GraphQL?

GraphQL is a data query language and execution engine open-sourced by Facebook in 2015. Its main benefit is that it works with any backend service. GraphQL API is a new architectural approach that heavily reduces the size of your API & the number of API calls.

![](https://graphqleditorcms.fra1.cdn.digitaloceanspaces.com/graphqleditorcms/media/graphql-vs-rest-1730828640362.webp)

If you want to read more about the GraphQL check [graphl.org](https://graphql.org/) or [howtographql.com](https://www.howtographql.com/).

## Now let's move to "You probably will hear that" part ...

#### Why don't stick to REST?

REST no longer gets it done. This observation was made by the Facebook team back in 2012 working on Facebook mobile apps. Standard REST APIs require the frontend team to call multiple URLs to fetch all the data they need, GraphQL uses only one endpoint which results in better performance on slow cellular connections which is still a very important issue.

#### Why should we use it?

Where to start? GraphQL is an interesting approach with much to offer. There are a lot of pros of GraphQL you can pitch to your team. These should do the job:

* **Performance** - with GraphQL you don't have to define dozens of service end-points to fetch data. GraphQL lets you request the amount of data you actually need it, which is difficult to achieve with REST-based services. This greatly improves performance, reduces the number of round trips to the server & reduces the amount of data transferred over the wire.
* **Faster prototyping** - GraphQL reduces the amount of code you need to write to achieve simple features. Less code means fewer bugs.
* **Great tooling** - GraphQL's popularity created an ecosystem of different supplementary tools bridging the implementation gap & [making GraphQL easier to adopt](https://graphqleditor.com/).

#### Is GraphQL secure?

GraphQL is no different from any other service end-point. As long as you will follow some of the basic security good-practices you can sleep soundly.

#### Is it production-ready?

Let's not beat around the bush - [YES#1](https://medium.com/airbnb-engineering/how-airbnb-is-moving-10x-faster-at-scale-with-graphql-and-apollo-aa4ec92d69e2), [YES#2](https://medium.com/paypal-tech/graphql-a-success-story-for-paypal-checkout-3482f724fb53)
Not enough? Here are a couple more ...

![](https://graphqleditorcms.fra1.cdn.digitaloceanspaces.com/graphqleditorcms/media/allusers-1730828660506.webp)

##### Source: [graphql.org](https://graphql.org/users/)

***

How to convince your team to use GraphQL?

[RapidAPI](https://rapidapi.com/) **is the world’s largest API Marketplace** that helps developers find and connect to thousands of APIs.

RapidAPI was founded in 2014 by Iddo Gino and after two years on the market raised $3.5 million, then to grab a stunning amount of **$38 million in The Series B** (including $25 million from Microsoft).

Yesterday RapidAPI **announced support for GraphQL APIs** to its and has published the first batch of them. Right now the platform offers just a few GraphQL-based APIs including GitHub, GitLab, Yelp, Reddit or Hacer News, with a lot more coming soon.

RapidAPI deciding to provide its marketplace users a choice between native GraphQL and REST API is a very clear signal that that GraphQL's market position is on a rise and will play an important role in the future of APIs.![](https://graphqleditorcms.fra1.cdn.digitaloceanspaces.com/graphqleditorcms/media/rapidgraphql-1730833673567.webp)

Developers using RapidAPI will get access to **GraphQL-native experience** allowing them to explore schema, develop, build & test their queries along with the same benefits known for RapidAPI users from its REST API experience:

* Publishing APIs via introspection or by uploading a schema file for easier onboarding,
* Interactive automatically generated docs enabling users testing the API right from a browser,
* Code snippets for easier integration with all the API provider’s applications,
* API management tools enabling to monitor performance metrics and data usage

![](https://graphqleditorcms.fra1.cdn.digitaloceanspaces.com/graphqleditorcms/media/rapidapi-1730833591416.webp)

RapidAPI extends offer for GraphQL APIs

etBrains is a company well-know for all developers. They have an impressive portfolio of dev tools among which the most popular ones are definitely IntelliJ (Java IDE) & Kotlin programming language.

JetBrains doesn't slow down in 2020 and they have just published their new product which is ... a font!
But not any font, its a font created by developers for developers and I must say ... **IT'S AWESOME!**

![](https://graphqleditorcms.fra1.cdn.digitaloceanspaces.com/graphqleditorcms/media/jetbrains-mono-1730830765983.webp)Source: [jetbrains.com](https://www.jetbrains.com/lp/mono/)

## Increased readability

Why this font is so special? **It's simple.**

**JetBrains Mono**’s typeface forms are free from unnecessary details which makes them easier to process for our brains. A number of specific typographic procedures have been performed **to increase the readability** such as:

* increasing the height of lowercase letters,
* easier distinguishing similar characters ( e.g. 1, l, I or semicolon with a colon).

Besides a couple of readability improvements the font also provides:

* 138 code-specific ligatures
* support 143 language
* is available in 4 weights with matching italics
* is **FREE & OPEN SOURCE!**

Take a look!

![](https://graphqleditorcms.fra1.cdn.digitaloceanspaces.com/graphqleditorcms/media/mono-1730830780340.webp)

If you love the concept of **JetBrains Mono** I have great news!
It's available under the Apache 2.0 license and can be [downloaded from the JetBrains website](https://www.jetbrains.com/lp/mono/).

JetBrains Mono - font for developers by developers

The [npm Inc. was right](https://graphqleditor.com/blog/javascript-predictions-for-2019-by-npm/), 2019 was a great year for GraphQL.
Let's take a look at the all good things that happened for GraphQL in 2019.

## January

[GraphQL Inspector](https://github.com/kamilkisiela/graphql-inspector) - a tool published by Kamil Kisiela, that detects changes, similar or duplicated types, validates documents against a schema and looks for deprecated usage.

![GraphQL Inspector CLI](https://graphqleditorcms.fra1.cdn.digitaloceanspaces.com/graphqleditorcms/media/inspector.webp)

## March

[AWS](https://aws.amazon.com/blogs/opensource/aws-joins-the-graphql-foundation/) **&** [IBM](https://developer.ibm.com/blogs/ibm-joins-the-graphql-foundation-to-push-for-open-source-adoption/) **joins the GraphQL Foundation!** - GraphQL Foundation is the GraphQL community aiming to enable widespread GraphQL adoption. AWS & IBM joining it is a strong signal that GraphQL has a bright future.
![GraphQL Foundation](https://graphqleditorcms.fra1.cdn.digitaloceanspaces.com/graphqleditorcms/media/foundation.webp)

[Apollo Client 2.5 was launched](https://www.apollographql.com/blog/announcement/announcing-apollo-client-2-5-c12230cabbb7) - a new version of Apollo Client was launched which merges local state management into the core library which has enabled a lot of cool features.

![Local state management with Apollo Client](https://graphqleditorcms.fra1.cdn.digitaloceanspaces.com/graphqleditorcms/media/apollo.webp)

## June

[Postman v7.2 Supports GraphQL](https://blog.postman.com/postman-v7-2-supports-graphql/) - Postman joined the group of companies acknowledging the GraphQL qualities and has recently announced the support for GraphQL in their service. The latest release of Postman v7.2 enabled sending GraphQL queries in the request body, GraphQL variables & GraphQL query autocompletion.

[Apollo Raises $22 Million](https://www.apollographql.com/blog/announcement/apollo-raises-22-million-to-simplify-app-development-ee30502c81b3) - Apollo raised a nice amount of $22 million to continue its mission to give a GraphQL-based data graph to every app developer in the world

[GraphQL Conf Berlin](https://graphql.org/conf/) - GraphQL Conf is a non-profit GraphQL conference organized by Prisma and Honeypot where industry experts from all around the world present GraphQL best practices and many more. In case you missed it, talks from GraphQL Conf 2019 are available on [Prisma's YouTube channel](https://www.youtube.com/playlist?list=PLn2e1F9Rfr6kChXoURShhO3A-4r8FLYsO)!

![GraphQL Conf](https://graphqleditorcms.fra1.cdn.digitaloceanspaces.com/graphqleditorcms/media/conf.webp)

**GraphQL: The Documentary** - the story of why and how GraphQL came to be and the impact it's having on big tech companies worldwide, including Facebook, Twitter, Airbnb & Github.

[https://www.youtube.com/watch?v=783ccP\_\_No8](https://www.youtube.com/watch?v=783ccP__No8)

## July

[Dgraph raises $11.5 million](https://dgraph.io/blog/post/how-dgraph-labs-raised-series-a/) - Dgraph is a horizontally scalable and distributed graph database, with a goal to provide enterprise-level scale and throughput, with low enough latency to be serving real-time user queries. Dgraph supports GraphQL-like query syntax, responds in JSON and Protocol Buffers over GRPC and HTTP.

![Dgraph](https://graphqleditorcms.fra1.cdn.digitaloceanspaces.com/graphqleditorcms/media/dgraph.webp)

## August

[Apollo Client supports React Hooks](https://www.apollographql.com/blog/announcement/frontend/apollo-client-now-with-react-hooks) - React 16.8 introduced a new way to write stateful components while avoiding the pitfalls of classes - the Hooks. Apollo Client now includes three hooks that you can implement in your app where corresponding higher-order component being used or render prop component: `useQuery`, `useMutation` &`useSubscription`.

## October

[Apollo Client 3 Beta](https://www.apollographql.com/blog/announcement/previewing-the-apollo-client-3-cache-565fadd6a01e) - Caching is considered by many developers as one of the GraphQL weaknesses. The Apollo team is on a mission to change that. New released Apollo Client 3 Beta contains some serious cache improvements.

[Graphql Editor 2.0](https://graphqleditor.com/blog/graphql-editor-new-release/) - a new version of GraphQL Editor packed with many micro-features to help developers save a lot of time & effort creating their GraphQL based APIs.

[![GraphQL Editor](https://graphqleditorcms.fra1.cdn.digitaloceanspaces.com/graphqleditorcms/media/graphqleditor.webp)](https://graphqleditor.com/)

[GraphQL Summit 2019](https://summit.graphql.com/) - GraphQL Summit is event of the year in GraphQL world. It's a world's largest conference dedicated to GraphQL, this year's edition featured over 60 technical talks across 3 tracks. Conference recordings are available here:

[https://www.youtube.com/watch?v=EDqw-sGVq3k\&list=PLpi1lPB6opQyraZSmwFre\_FpL00\_3nTzV](https://www.youtube.com/watch?v=EDqw-sGVq3k\&list=PLpi1lPB6opQyraZSmwFre_FpL00_3nTzV)

2019 in a summary - GraphQL perspective

Any **"The Office"** fans here?

Do you remember the episode in which Jim put Dwight's stuff into a vending machine? This seems to be one of the best examples of the major difference between **GraphQL vs REST** according to, one of the GraphQL’s creators, **Lee Byron**.

![](https://graphqleditorcms.fra1.cdn.digitaloceanspaces.com/graphqleditorcms/media/vending-1730821962293.webp)

## The Vending Machine Case

In that episode, Jim puts Dwight's belongings into a vending machine. Among them where coffee mug, bobble-head, nameplate, pencil cup ... and Dwight's wallet. Not to leave him empty-handed, Jim provided Dwight a bag of nickels.

To retrieve his item from a vending machine Dwight should:

1. Use nickles to retrieve his wallet
2. Use quartes, halves to retrieve the first object
3. Repeat the procedure for every item he wants to retrieve

That's the way the vending machine operates. The pattern is similar to those we know from using the **REST API**. Imagine we want to retrieve posts from a company blog using rest:
![](https://graphqleditorcms.fra1.cdn.digitaloceanspaces.com/graphqleditorcms/media/posts-1730821974521.webp)
and if you want to add authors you will need to fetch the from another resource (or modify your resource containing posts) you'll end up with two server requests instead of one (or extra work), and as you continue to scale, you may have even more requests to different endpoints in order to fetch all the needed data:
![](https://graphqleditorcms.fra1.cdn.digitaloceanspaces.com/graphqleditorcms/media/post-id-1730821987461.webp)
This is exactly our vending machine, where to get one item you need to press one button. If you want to get more items you need to get the one-by-one, repeating the procedure for different items.

## A vending machine with **special buttons**

Now imagine a vending machine with special buttons allowing you to get multiple things at once. This kind of super vending would help Dwight's get his stuff back super fast and it's exactly what **GraphQL API** does in terms of retrieving data.
![](https://graphqleditorcms.fra1.cdn.digitaloceanspaces.com/graphqleditorcms/media/gql-1730822010106.webp)
In GraphQL we have a single endpoint being able to process complex requests. You query the **GraphQL server** for specific data and it will respond with what was requested, which results in fewer bits transferred over the wire.

![](https://graphqleditorcms.fra1.cdn.digitaloceanspaces.com/graphqleditorcms/media/graphql-vs-rest-1730822029945.webp)

GraphQL vs REST - a vending machine example


[[[GraphQL Zeus](/docs/zeus)](/docs/zeus)](https://github.com/graphql-editor/graphql-zeus) is an open-source ([MIT](https://github.com/graphql-editor/graphql-zeus/blob/master/LICENSE.md)) graphql client & code generator working with a **Browser, Node.js & React Native**. It provides an auto-complete client library for JavaScript or TypeScript supporting auto-completion for strongly typed queries. It's maintained by [Artur Czemiel](https://twitter.com/ACzemiel) (follow him on Twitter for latest [GraphQL Zeus](/docs/zeus) news & updates).

## Installation & Basic usage

To play with it use npm install:

```ts
$ npm i -g graphql-zeus
```

Zeus supports:
- Javascript (Browser, NodeJS, React Native)
- TypeScript (Browser, NodeJS, React Native)

![Zeus in action](/zeusexample.webp)

[GraphQL Zeus](https://github.com/graphql-editor/graphql-zeus) provides many useful solutions among which you can find such as:

- **Chain** - Chain is the main function responsible for forming a GraphQL Query. It provides auto-complete in Zeus Syntax. Returned data is mapped accordingly to GraphQL query, so you get type-safe completion for both query and response in both *TypeScript* and *JavaScript*.



- **Aliases** - You can alias each query just like in GraphQL original specification. To use `alias` you just need to provide `__alias:{[YOUR_ALIAS]:YOUR QUERY}`

- **Selectors** - If you use same GraphQL query many times you can use `Selectors` which you can later inject into the `Chain` function


###JavaScript &  React Native:

```ts
$ zeus schema.graphql ./
```

### TypeScript:

```ts
$ zeus schema.graphql ./  --ts 
```

### Node.JS:

```ts
$ zeus schema.graphql ./  --node 
```

## Want to contribute? 
Awesome, just:
1. Fork this repo
2. Create your feature branch: `git checkout -b feature-name`
3. Commit your changes: `git commit -am 'Add some feature'`
4. Push to the branch: `git push origin my-new-feature`
5. Submit a pull request





Boost your GraphQL development with GraphQL Zeus

If you would like to start your adventure with the [GraphQL](https://graphql.org/) but you are not sure how we have prepared a small interactive tutorial for you to familiarize yourself with basic **GraphQL syntax** and its elements.

During six short lessons, you will learn the basics allowing you to start working on your first **GraphQL schema** like:

* [GraphQL Type](/docs/what-is-graphql/)s
* Queries
* Mutations
* Inputs
* Enums

Click the button below and you will be redirected to the **GraphQL Interactive tutorial** :

![](https://graphqleditorcms.fra1.cdn.digitaloceanspaces.com/graphqleditorcms/media/button-1730829343501.webp)

![](https://graphqleditorcms.fra1.cdn.digitaloceanspaces.com/graphqleditorcms/media/tutorial-1730829354342.webp)

If you are looking for more **GraphQL resources** make sure to check:

* [GraphQL Official Documentation](https://graphql.org/learn/)
* [How to GraphQL](https://www.howtographql.com/)

Happy learning!

Blog