

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!

Interactive GraphQL Tutorial for beginners

[Ghost](https://ghost.org/) is a very popular open-source publishing platform, described by many as a modern alternative to WordPress. Their premise is making publishing as easy as possible and they do deliver!

Ghost has proven its usability by gaining the trust of such tech giants like [Mozilla](https://www.mozilla.org), [OpenAI](https://openai.com/), [Apple](https://www.apple.com/), [Tinder](https://tinder.com/), [DuckDuckGo](https://duckduckgo.com/) and thousands of small & medium companies.

A week ago big news hit the Internet that the new version of Ghost is available and I think that the release timing wasn't a coincidence ... **Happy Halloween ;)**

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

As mentioned by its developers, [Ghost 3.0](https://ghost.org/) is all about enabling new business models for publishers.

#### Ghost 3.0 features:

* **Native support for memberships** - allowing you to easily turn your anonymous page viewers into registered users,
* **Stripe integration** - to enable subscription business model for all publishers (Ghost takes 0% transaction fees!)
* **JAMstack native architecture** - documented integrations with [Gatsby](https://www.gatsbyjs.com/), [Next](https://nextjs.org/), [VuePress](https://vuepress.vuejs.org/), and more.
* **many new integrations** - you can use your favorite services with Ghost, the full list is available [here](https://ghost.org/integrations/)
* and of course, it remains **an open-source platform**!

If that's not enough and you are still hesitating if you should give Ghost a try it is also worth mentioning that:

* has blazing-fast & modern codebase,
* fully open-source permissive **MIT license**,
* much **cheaper than WordPress** (see below)

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

###### Source: [ghost.org](https://ghost.org/vs/wordpress/)

#### Ghost + Gatsby (GraphQL)

One of my favorite things about Ghost is that it works great with [Gatsby](https://www.gatsbyjs.com/) & Gatsby equals [GraphQL](https://www.gatsbyjs.com/docs/conceptual/graphql-concepts/). GraphQL is a query language for APIs where when you ask for data you get exactly what you need - nothing more, nothing less. This how it looks compared to REST.

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

###### Source: [blog.apollographql.com](https://www.apollographql.com/blog/graphql/basics/graphql-vs-rest)

Fetching data from the Ghost API for a Gatsby site is very simple, especially when using GraphQL. Let's take a look at some basic operations that can be done to retrieve data from the Ghost API with GraphQL.
Take a look at these common examples of operation you probably need to perform when using GraphQL to query the Ghost API for your company page, news site or blog. All examples come from [Ghost docs](https://ghost.org/docs/content-api/).

#### Fetching posts

In this example, we take a limited amount of posts per page & use ‘skip’ to paginate through pages containing those posts:

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

###### Source: [ghost.org](https://ghost.org/docs/content-api/)

#### Filtering Posts

Filtering posts by tag is a widely used case:

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

###### Source: [ghost.org](https://ghost.org/docs/content-api/)

#### Retrieving settings

The Ghost settings node differs from other nodes (it’s a single object). To query it you need to:

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

###### Source: [ghost.org](https://ghost.org/docs/content-api/)

#### Retrieving the list of all tags

Getting all tags from a Ghost site is simple. You could them to form a tag cloud or a keywords list:

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

###### Source: [ghost.org](https://ghost.org/docs/content-api/)

New Ghost 3.0 and how to use it with GraphQL (Gatsby)


Since open-sourcing [GraphQL](https://graphql.org/) specification in 2015, it gained a lot of popularity and is now used by many development teams, including giants like GitHub, Twitter or Airbnb. Why? Because GraphQL lets you describe the complex data dependencies with ease, another great thing about it is that you can use it with any language or platform.

The rising popularity of GraphQL led to the formation of local meetups of GraphQL users. One of the most active European communities is a group of GraphQL fans from Berlin. If you are not from Berlin or subscribing [GraphQL Weekly](https://www.graphqlweekly.com/) (if so it's a good moment to do it), you might have missed the recordings of their recent meetup that took place at Berlin [Prisma](https://www.prisma.io/) office.

## The talks from GraphQL Berlin Meetup #15

#### "System Design and Architecture @ GraphQL" by Bogdan Nedelcu

Designing GraphQL API's for scale is quite a challenge as GraphQL is relatively a new technology. Bogdan Nedelcu talked about system architecture patterns that have been around for a long time that GraphQL bases on.

https://www.youtube.com/watch?v=S22rYsesrQc

#### "Pursuing Singularity" by Roman Paradeev

During his talk, Roman Paradeev made an overview of tools that provide type safety across your database, API & client-side in the GraphQL ecosystem.

https://www.youtube.com/watch?v=yN8NBXdRRfc

#### "Key learnings from implementing authentication and authorization using GraphQL" by Christoph Hartmann

Basing on his experience with GraphQL implementation Christoph Hartmann presented different approaches to implementing authentication and authorization for GraphQL services.

https://www.youtube.com/watch?v=pF6SH7Tm6Pc


Inspiring talks from GraphQL Berlin Meetup

Some time ago I have read that:

> *GraphQL is really about collaboration, and the teams that get furthest are those who work closely together on their GraphQL API.*

This idea is very true but collaboration becomes a very tricky part of any development project where there are multiple teams involved. So a question arises, is there any way to make collaboration on a GraphQL API easier & more pleasant experience? I think that it's possible!

Let me introduce you three ways of strengthening your GraphQL API which might save your teams from jumping at each other's throats.

### #1 Install GraphQL Code Inspector

[GraphQL Inspector](https://the-guild.dev/graphql/inspector) is a CLI tool from [The Guild](https://medium.com/the-guild) member [Kamil Kisiela](https://github.com/kamilkisiela/), that detects changes, similar or duplicated types, validates documents against a schema and looks for deprecated usage, everything as simple as this:

```ts
$ graphql-inspector diff OLD_SCHEMA NEW_SCHEMA
```

There is also a programmatic API available in case you want to build something on top of it on your own.

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

##### Source: [GraphQL Inspector](https://medium.com/the-guild/graphql-inspector-481c1a5ef616)

### #2 Use GraphQL Editor

The [GraphQL Editor](https://graphqleditor.com/) is a tool to build, manage and collaborate on your GraphQL schema visually! It includes features that help you make sure that your GraphQL API and its clients are well-developed. The latest update introduced a couple more interesting features like:

* **Autocomplete for Queries** - Create an auto-complete library for JavaScript or TypeScript with a built-in [[GraphQL Zeus](/docs/zeus)](https://github.com/graphql-editor/graphql-zeus) feature.
* **Schema versioning** - with a click of a button you can see & manage all changes.
* **Schema Libraries (Schema stitching done right)** - built-in GraphQL libraries allow you to create new GraphQL schemas from multiple underlying GraphQL APIs.
* **Fake backend** - allowing you to run a GraphQL Server with faked data available for testing with a single click.

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

### #3 Why not use both?

Get your GraphQL API a bulletproof vest by combining these two tools!

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

Blog