A weekly newsletter of the best news, articles and projects about GraphQL

This post explores some of the complications faced when designing the mutations part of a GraphQL API and the best practices to follow based on the Relay's API spec for mutations. David Chanin explains how these practices are applicable more generally, even if you're not using Relay on the frontend.

A thought provoking and opinionated post about the semantic differences between GraphQL and REST and how they can't be directly compared as one is a query language while the other is an architectural style. Fagner Brack challenges in the post common conventions and includes a list of interesting resources on the topic.

This blog goes in-depth on the origins of federation, the design and implementation of a federated graph architecture, the components of federation, and more. The article explains how federated architecture, although fairly new, helps simplifies, in a highly optimized manner, the problem of bringing multiple schemas from different micro services together and merging them into one unified graph API.

Check out this tutorial that demonstrates how to use multiple databases in Neo4j 4.0 and how to use multiple active databases with the Neo4j GraphQL integration, building a multi-tenant GraphQL API. William Lyon includes example code on how to setup and create a GraphQL schema and Neo4j driver instance. He also provides resources at the end of the tutorial for more information on multi-database support with Neo4j and GraphQL.

This post explores the important performance considerations for building apps at scale and how Hasura GraphQL Engine leverages PostgreSQL query caching and prepared statements to improve performance. Some interesting metrics are provided as the article breaks down the multiple stages of processing an incoming GraphQL query. Praveen Durairaju explains how Hasura’s architecture allows for GraphQL query plans to get cached and SQL query plans to get cached by Postgres with prepared statements.

Sarah Drasner shares the advice and notes from a NodeSF meetup where Francesca Guiducci gave a talk on A GraphQL Guide for Backend Developers. This post dives into how to determine if GraphQL fits into your architecture, whether it’s putting a GraphQL server in front of a database or using GraphQL as a wrapper around existing APIs. She further explains the details and best practices of schema design, providing examples while sharing the challenges that come with using GraphQL.

This article discusses an approach to GraphQL schema design that involves both non-technical domain experts and developers. Khalil Stemmler takes you step by step using event storming to design and build a GraphQL schema, showing the different use cases for when CRUD doesn’t fit.

In this article, Sean Dearnaley explains the powerful combination of TypeScript and GraphQL and the learning outcomes of type safety. These tools combined offer the ability to construct powerful and practical programming interfaces that can be used by all GraphQL consumers. Learn how to evolve an API without endpoint versioning by using Typescript.

This article by Andi Marek provides a deep deep dive into scalars. The article helps readers understand GraphQL scalars and learn how to write custom ones. The examples provided within the article are in GraphQL.js but the focus is on the fundamental concepts, especially Coercion.

With the start of each year predictions and discussions about the upcoming trends in GraphQL are becoming a tradition. In his recent article, Marc-Andre Giroux covers some of the trends he expects this year. He speaks to transport specific implementations/optimizations, alternative execution algorithms/engines, and a greater focus on GraphQL's tradeoffs.

MongoDB has added support for GraphQL in its cloud DB service, MongoDB Atlas. This New Stack article covers the details of the launch, how the functionality was integrated with Mongo and what requirements the company outlines to get started with the feature.

An illustrated article with helpful sketches, Stav Barak's introduction to GraphQL is a great summary about the technology for people curious to learn about what GraphQL is and does. Covering the advantages that GraphQL has over REST, Stav offers up examples throughout the piece. A great article for newcomers to GraphQL.

This in-depth article introduces the concept of discriminated/tagged unions in GraphQL and how to leverage them to write more extensible applications. The article includes examples of GraphQL unions and how they are represented as tagged unions at runtime. Kevin Saldaña also discusses ReasonML and demonstrates the power of variants and pattern matching in Reason. He explores the power of Hindley-Milner type inference and pattern matching, which can be combined to efficiently write highly type-safe applications.

Sebastian Scholl from the 8base team shares how they were able to build a full-featured group and aggregations enabled GraphQL API with direct SQL access while still within the confines of GraphQL. Sebastian runs through how they utilize aliases that allows for dynamic types and attribute-names to be used.

Learn about the potential ways to resolve data for a GraphQL endpoint using RESTful APIs and how to utilize Apollo’s REST Data Source library in Khalil Stemmler’s deep dive into an optimized GraphQL server. Find out how request dedication and resource caching works in REST Data Source. The article also provides tips to implement your own resource cache using the apollo-server-caching library.

This article discusses some advanced topics using GraphQL with Apollo SDK and Swift, including the usage of GraphQL fragments and Swift scalar types as well as the pros and cons to using GraphQL. Kristaps Grinbergs demonstrates how to use your own types for custom scalars and improve your code base with custom initializers for your app models.

In this article, learn more about the unexpected quirks to web application behavior that GraphQL introduces. The article runs through how the technique of batching works and how it can cause security problems, such as the inconsistencies of implementations, mutation operations that work with user authentication, and more. At the end, the article offers some tips on how you can safely secure your GraphQL applications against batching attacks.

This article speculates the benefits of combining GraphQL and the Semantic Web because of the commonalities between the two technologies. Some core Semantic Web mechanisms and existing resources can help enhance GraphQL data integration and its publishing capabilities. Szymon Klarman provides interesting commentary on how GraphQL and URIs can open the door to global knowledge graphs and improved data environments.

This blog takes a look into performing GraphQL queries and how to configure your project to communicate with a sample API. Joe Birch introduces a GraphQL setup with coroutines and how it can improve the approach to asynchronous operations. He provides sample code throughout the article to explain how to utilize GraphQL schemas and queries to build out a project.

This article discusses the importance of cost computation and limiting the size of server responses to prevent memory overload. Scott Malabarba explains how to calculate costs based with a sample schema of a book list app. He provides some solutions, like adding query cost computation and limits in complex data models, to add robustness and flexibility to your GraphQL APIs.

Tom Nagle provides insight into GraphQL security vulnerabilities that are useful to keep in mind when building a large-scale enterprise application or even a simple side project. He breaks down major threats, like brute forcing vulnerable mutations, and offers detailed solutions against various attacks. The article includes sample code as well as helpful tools to prevent your schema from being leaked in public environments.

In this quick tutorial, learn how to set up and use the Apollo iOS SDK library, which supports GraphQL subscriptions. You can generate all the subscriptions using the GraphQLSubscription protocol, passing parameters to the subscription you want to implement. The tutorial teaches how to utilize the GraphQL subscription feature to listen and send real-time messages using WebSockets.

This blog discusses how Airbnb successfully migrated their large API to GraphQL, which led to improved page load times and a more intuitive user experience. The blog talks about the stack Airbnb used, how they handled aliasing and adapters to convert a GraphQL response, stage management, and other features in the project. Thomas Betts also explains all the benefits and improvements for Airbnb ever since they switched to GraphQL over REST.

This article shares some key learnings on utilizing DynamoDB to develop a fully serverless GraphQL API in production. It discusses which query access patterns are important, how to handle proper abstractions and create your own opinionated ORM, and more. Learn the dos and don’ts to prevent your table from consuming too many write capacity units and enable large scalability.

This blog post does a deep dive into GraphQL performance by examining what GraphQL implementation is doing. The post explains parsing, validation, and execution of a GraphQL query, and how we can reduce performance overhead of the GraphQL API with precompiled queries and mutations. Although applications that use GraphQL can be slightly slower initially, this article provides some tips on how to tweak them to achieve better performance results.

Learn from the Netflix Marketing Tech team about a different approach to searching with GraphQL and how to index data and make it searchable. The team shares how they used the relationships and schemas defined within GraphQL to automatically build and maintain a search database. The blog goes through the challenges of searching decentralized data, keeping everything up to date, periodic indexing, and more.

Check out this brief of the research paper “An Empire Study of GraphQL Schemas” that provides a summary of what GraphQL is, what performance benefits a GraphQL API offers, and what a “typical” GraphQL schema looks like. The research examines the differences between open-source schemas versus commercial schemas, using their findings to discover trends and consistencies in naming conventions, schema designs, and pagination patterns.

In this blog, Dgraph focuses on sharing how GraphQL was chosen as the native query language to build their graph database and the common issues their GraphQL engineers face. Manish Rai Jain explains how Dgraph extends the GraphQL syntax so that any part of a query can be collected in a variable. This blog also offers solutions to the N+1 problem and how to avoid latencies/performance concerns.

Learn more about GraphQL best practices based on the observations PayPal has made while building GraphQL APIs. Mark Stuart discusses the adoption, tooling, and the journey from REST to Batch REST to finally GraphQL. With adoption, PayPal faced some challenges with enterprise scaling, handling authentication/authorization, and assembling a cohesive graph. The article provides great insight into how the engineering team at PayPal handled all the nuances the come with implementing GraphQL.

After Prisma transferred the GraphQL CLI over to The Guild, they completely rewrote the project and closed over 100 issues. In his blog post about it, Urigo shares the updates made to the GraphQL CLI, its new features, and the variety of tools it integrates with. As the project is in an alpha phase, they also seek feedback from users and tools creators!

Marc-André Giroux describes his experience and learnings from the API Specifications Conference, where he noticed that most GraphQL APIs seem to be either private or partner related. This article breaks down what conventions can lead to good public APIs, which use cases to focus on, and how to secure APIs. He also provides his thoughts on the future of public GraphQL APIs and potential tradeoffs for developers and other companies.

This article by Bogdan Nedelcu questions the process of adopting GraphQL in replacement of traditional REST APIs. He breaks down the well-known design patterns, like the API Gateway, Integration Database, and Data Federation pattern, while discussing the advantages and limitations that GraphQL inherits from these patterns. The article also provides tips on solution patterns for GraphQL that can be used to help scale and increase development speed.

This brief article explores some options to help make collaboration on a GraphQL API a smoother experience. Tomek Poniatowicz uses GraphQL Inspector, a CLI tool, to detect changes and validate documents against schemas to improve development efficiency. He also mentions the GraphQL Editor tool that helps build and manage GraphQL schemas visually, including the different features the tool has. Learn more on how you can improve the structure and development of your GraphQL APIs in this article.

This interesting article by Marc-André Giroux discusses the power of HTTP/3 and how multiplexing changes HTTP APIs. He questions whether the reasons to use GraphQL are still valid, since part of GraphQL’s appeal is that it helps manage HTTP/1 connections better. He also argues for both benefits and downfalls of HTTP/2 and GraphQL, mentioning his thoughts on what the future of APIs might look like.

This blog examines the foundation of GraphQL and the community’s differing responses on the rise of implementation and increasing replacement of REST. Matt McLarty shares some advice to GraphQL advocates, REST experts, and those alike. He proposes that GraphQL and REST should no longer be separated into such distinct dichotomies, but should work together and coevolve to create better, well-designed APIs.

A great walkthrough on how to use the brand new Serverless Components to deploy a GraphQL API on AWS in minutes. The step by step tutorial takes you through every step from configuration all the way to consuming your lambda deployed GraphQL API.

A simple yet insightful tutorial for React Native developers trying to learn GraphQL. Jamie, the author, helps you harness ApolloClient to build a beautiful coffee e-commerce native application. By providing strategies on how to use context for better state management, this articles even touches on some best practices for React Native architecture and data management.

This article discusses what N+1 queries are, how they are easily produced in GraphQL, and how to solve them using the graphql-batch gem along with a few custom batch loaders. Leigh Halliday also covers the techniques to optimize GraphQL queries, efficiently handle batch loading, and lazy-load data only when required. To get started, the source code and resources can all be found throughout the article.