April 2018 Summaries

The next generation of schema stitching is now available in graphql-tools 3.0, which simplifies and improves the process of combining multiple GraphQL APIs or using an existing API in a new one. This release introduces a new concept called "schema transforms," which enables modifying schemas before or after they are stitched together, making it easier to handle conflicts and avoid exposing unnecessary fields. The new feature also includes pre-implemented transforms for common use cases such as filtering, renaming, and delegating to existing schemas. With graphql-tools 3.0, developers can now reshape GraphQL schemas at will while ensuring all queries work as expected, which is critical for namespacing, schema conflicts, and limited access to specific fields. The new release also includes a set of examples and documentation to help users get started with implementing their own transforms.

Sashko Stubailo from the Apollo team has announced an integration of GraphQL metrics with Datadog, a popular monitoring and analytics platform. The integration allows developers to easily pipe metrics into Datadog, providing performance and error statistics such as request rates, error rates, cache hit rates, and latency histogram statistics. The data is tagged with GraphQL-specific information, enabling easy filtering by operation name. This integration is available on the Engine Standard and Pro plans, which also include benefits like longer data retention and proactive alerting. The integration makes it easier for developers to bring their favorite tools into their GraphQL workflows, allowing them to use existing technology investments in a way that works with their GraphQL API.

The text discusses modularizing GraphQL schema code by splitting up the schema types and associated resolvers into multiple files. It presents a straightforward method for doing so using JavaScript concepts, allowing developers to organize their codebase in a logical and efficient manner. The approach involves importing type definitions across different files, combining them later, and separating resolver code from schema definition files. Additionally, it introduces the concept of type extensions, which enables defining new fields on existing types without modifying the original type definition. This allows for better organization and reusability of code, making it easier to maintain and extend the GraphQL application as it grows in complexity.

Apollo Engine's new Alerts feature provides proactive monitoring for GraphQL APIs, enabling teams to respond quickly to performance issues and errors. With flexible configuration options, users can set thresholds on request rate, request duration, error rate, and error percentage to receive notifications when problems arise. The alerts are evaluated on a rolling five-minute window, allowing for timely resolution of issues. To set up alerts, users can access the new ALERTS tab in their Engine account, where they can configure alert channels and trigger values. Additionally, users can monitor what matters most to their users by setting up per-operation triggers or using service-wide triggers as safety nets. With this feature, teams can ensure their APIs are running smoothly and respond promptly to issues, without being woken up at 3 am for minor issues.

GraphQL schema delegation allows for the automatic forwarding of GraphQL queries or parts of them to another schema without manually querying them. This enables reusing parts of other schemas without having to query them directly. Schema delegation is particularly useful in scenarios such as building a GraphQL gateway that forwards queries to underlying microservices, using a third-party GraphQL API, or utilizing a GraphQL database proxy like Prisma. By implementing a `Node` interface on top of the service schema and reusing existing types, the gateway can delegate root fields from the original schema to the delegated schema, allowing for more efficient data retrieval and reduced overhead. The `delegateToSchema` function in `graphql-tools` simplifies this process by automatically filtering out incompatible fields and fragments, as well as unused ones, making it easier to implement schema delegation. Additionally, schema delegation can be combined with schema stitching to create a gateway schema that combines multiple services, setting up automatic delegation for root fields that already exist in the stitched schemas.

Sashko Stubailo discusses how GraphQL can be used with Content Delivery Networks (CDNs) to cache API results, improving load times and reducing server load. He addresses common misconceptions about using CDNs with GraphQL, including the idea that requests are too diverse or too large, and shows how tools like Apollo Engine and Apollo Cache Control can address these concerns by providing static queries, smaller request sizes, and fine-grained cache control hints. With these tools, it's possible to integrate GraphQL into an existing setup, add data loading to a React app, and easily integrate with existing application infrastructure. The author shares his excitement about the benefits of using CDNs with GraphQL and looks forward to seeing more tools work together across the stack.