October 2017 Summaries

The new Trace view in Apollo Engine provides a visual representation of GraphQL query execution, allowing developers to explore the critical path of their queries, understand how much time is spent outside resolvers, and identify exactly when resolver execution starts and ends. The feature has been significantly upgraded from its predecessor, Optics, and now offers a more detailed and interactive experience for analyzing query performance. With this new tool, developers can gain valuable insights into the performance of their GraphQL servers and make data-driven decisions to improve their applications.

Apollo Client 2.0 is a community-driven GraphQL client for React, Vue.js, Angular, and other JavaScript platforms, allowing developers to describe data requirements with a GraphQL query and fetching and managing data automatically. It's used in production by companies like KLM, IBM, Intuit, and more, and has over 2 million downloads so far. The new version is designed to bring the benefits of GraphQL to all data management needs, with a small core size of only 12kb and modular and extensible architecture. Apollo Client 2.0 introduces a network layer powered by observables, enabling features like live queries and support for multiple results from operations. It also aims to expand on existing ideas and build towards a world where all application data can be managed via GraphQL, with new features like stream your data, client state and REST join the fun, and better native and PWA support. The project values simplicity and has rewritten its documentation to focus around features, best practices, and recipes for real-world use cases.

Apollo Engine is a new turnkey infrastructure that helps developers take GraphQL services into production with confidence. It delivers essential capabilities like query caching, error tracking, and execution tracing on top of any spec-compliant GraphQL server, including Apollo Server, GraphQL-Ruby, Sangria, and Absinthe. Engine provides integrated GraphQL query caching, error tracking, query execution tracing, schema analysis, API usage trends, and a hybrid prem architecture that offers low latency, high availability, and security. The new feature of GraphQL-aware caching allows for performance optimization features to be optimized in the query path, enabling developers to specify exactly what parts of a response can be cached and for how long. Apollo Engine is free forever for the first million requests each month and costs $9 per additional million queries beyond that.

The Apollo Tracing extension for GraphQL servers enables performance monitoring by including trace data in the `extensions` field of the response. This allows developers to visualize and analyze the performance of their resolvers, similar to how error paths are handled in the GraphQL spec. The tracing format is designed to be flexible and include detailed timings and type information for individual resolvers. With support built-in for Apollo Server, users can easily enable tracing by setting `tracing` to `true`. The extension already works with popular server libraries such as Node, Ruby, Scala, Java, and Elixir, and the community is encouraged to contribute support for other servers and tools.

The text discusses the Apollo Link library, which is designed to be a powerful way to compose actions around data handling with GraphQL. A link represents a subset of functionality that can be composed with other links to create complex control flows of data. Links are isolated parts of the control flow and can perform side effects, modify operations, or provide developer tools. The core concept of a link is its `request` method, which takes a GraphQL request and returns an observable. Links can be composed using the `from` or `concat` methods to create chains of links. The `split` method allows for directional composition, where different links are used depending on the operation itself. Links can be stateless or stateful, with stateless links being simple functions wrapped in the `ApolloLink` interface and stateful links keeping track of operations using a unique key. The library aims to provide flexibility and customization options for GraphQL applications, with the goal of becoming like react components on npm.

Apollo Engine and GraphQL error tracking` The Apollo Engine is a technical preview of Optics, a new version designed to visualize, monitor, and scale GraphQL services. The new feature focuses on error tracking in GraphQL, addressing several problems including capturing multiple errors per query, zeroing in on errors by field or path, highlighting failed resolvers with execution timing data, and charting error rates alongside query volume. Engine is built on a new architecture using an embedded GraphQL proxy, which supports more languages and environments, and uses Apollo Tracing to expose trace data. This new approach allows for accurate tracking of errors even in cases where the GraphQL server crashes or is corrupted, and enables features like request rate limiting and GraphQL query caching. The preview is available free of charge, with plans to announce pricing in coming weeks.

Apollo Tote is a declarative React component that helps simplify Apollo queries by providing a simple helper library for your queries until declarative components are released in Apollo 2.0. It allows developers to apply JSX directly to their containers, making it easier to manage authentication and authorization states, handle loading and error states, and render complex data structures. The component uses render props to make these tasks more manageable, and its API is designed to be similar to that of Apollo 2.0, allowing for a smooth transition when the declarative components are released. By using Apollo Tote, developers can take advantage of its features until the declarative components are available, making it an attractive option for those working with Apollo and React Native.

The GraphQL-Tools team has released version 2.0 of their library, which includes a new feature called "schema stitching". This allows developers to create a single GraphQL schema from multiple underlying GraphQL APIs, unlocking potential in GraphQL development. The team was inspired by feedback from users and designed the feature to be modular and flexible, with options for extending schemas and resolving conflicts between types. The library provides an API for merging schemas, including examples of simple and complex use cases, and is available on Launchpad. The team plans to continue improving the API in response to community feedback and will be attending GraphQL Summit 2017 to share their work and learn from other engineers.