GraphQL Galaxy 2022

The Talk discusses the challenges and advancements in using GraphQL and React together. It introduces RedwoodJS, a framework that simplifies frontend-backend integration and provides features like code generation, scaffolding, and authentication. The Talk demonstrates how to set up a Redwood project, generate layouts and models, and perform CRUD operations. Redwood automates many GraphQL parts and provides an easy way for developers to get started with GraphQL. It also highlights the benefits of Redwood and suggests checking out RedwoodJS.com for more information.

GraphQL has made a huge impact in the way we build client applications, websites, and mobile apps. Despite the dominance of resolvers, the GraphQL specification does not mandate their use. Introducing Graphast, a new project that compiles GraphQL operations into execution and output plans, providing advanced optimizations. In GraphFast, instead of resolvers, we have plan resolvers that deal with future data. Graphfast plan resolvers are short and efficient, supporting all features of modern GraphQL.

This Talk discusses handling breaking changes in a GraphQL schema, including the use of the deprecated directive to tag fields that should no longer be used. It also covers the process of deploying GraphQL APIs and mobile apps, highlighting the challenges of mobile app release adoption. The Talk emphasizes the importance of making safe upgrades in mobile apps and provides strategies for detecting and handling breaking changes, such as using TypeScript and GraphQL Inspector. Overall, the Talk emphasizes the need to minimize user impact when introducing breaking changes in GraphQL schemas.

Today's Talk is about GraphQL Yoga version 3, its evolution, improvements, and features. Yoga version 3 is easy to get started with, production-ready by default, and fits into any existing stack. It offers upgrades to GraphQL 2, simpler subscriptions, and a powerful deference stream feature. Yoga aims to make production deployment easier with error masking, validation and parser caching, health checks, and integration with JavaScript runtimes. The Talk also highlights the extendability of Yoga through plugins and its battle-tested nature in production.

GraphQL is successful due to its tooling and customizability, but developers face challenges such as learning, syntax, schema exploration, API building, visualization, documentation, and collaboration. GraphQL version 2 has made significant improvements, including a plugin API and building blocks in GraphQL React. Customization in GraphQL involves overriding CSS variables and building custom functionality using plugins. The ability to embed a GraphQL IDE into a blog allows users to interact with GraphQL concepts directly. Overall, GraphQL continues to evolve and adapt to the changing needs of its ecosystem.

GraphQL is a preferred tool for solving the complex data access challenge in the current ecosystem. It allows merging diverse sets of data into a single API, reducing overhead and providing reusable patterns. GraphQL's purpose is to define data dependencies and it aligns with accessing complex data models and federated data dependencies. Hasura introduces the GraphQL data specification, a powerful tool for defining data needs and creating APIs. They are actively hiring and encourage users to try out their alpha release and provide feedback.

The talk discusses the defer directive in GraphQL, which allows clients to specify parts of a query that can be delivered incrementally. It addresses the problem of higher latency fields while still having a single response. The talk explores different approaches to solving this problem, such as query splitting and prefetching. It also covers examples of using the defer directive for partial rendering and lazy loading, as well as its use in mutations. The talk emphasizes the importance of performance for user experience and provides resources for further exploration.

Hi, everyone! Today, I'll be discussing the future of GraphQL Code Generator and the new features that enhance the developer experience. Code Gen has evolved significantly since its creation in 2016, from generating simple types to hooks and now to a new feature. It has expanded to support multiple languages and framework-specific plugins. Code Gen is widely used in the GraphQL stack, with 7 million monthly downloads on NPM. The new features include Type Document Node, which allows typing GraphQL operations without hooks, and the Client Preset, an improved version of Type Document Node. The Client Preset provides a seamless developer experience by generating the GraphQL function that returns the proper type document node type to your variable. Another interesting feature is fragment masking, which simplifies the usage of fragments in GraphQL and allows for better understanding of data dependencies within the component tree.

GraphQL at Facebook started as a solution for the migration to structured product infrastructure and the move to mobile. The birth of FQL highlighted the need for a better tool than SQL. The impact of GraphQL has been impressive, with unexpected growth and usage in various domains. Exciting developments include new features like defer and stream, making GraphQL a live, continuous data delivery and UI rendering tool. Personal experiences with GraphQL involve using it to move data between backend and frontend, with challenges in integrating it into IDE environments.

This Talk is about real-time data updates for Neo4j using GraphQL subscriptions. The Neo4j GraphQL library provides automatic schema generation, read queries, mutations, and resolvers. It handles subscriptions using WebSockets and is completely agnostic. The library also has built-in support for events and relationships, allowing for real-time updates and easy scaling. The Talk concludes with details about subscriptions using AMQP and a showcase of Neo4j GraphQL subscriptions in a project called neo place.

We discuss GraphQL servers, their current state, and how to harden resolvers. The talk explores the working of resolvers, handling server outages, and implementing passive health checking. It also delves into the role of API Gateways, proxies, and declarative resolvers in improving network traffic handling. The use of JQ for data transformation and outlier detection is demonstrated. The talk concludes with the importance of resilient resolvers and engagement with the GraphQL community.

The Talk discusses the value proposition of GraphQL and its ability to solve common pain points in API development. It highlights the importance of making informed decisions when choosing GraphQL clients, servers, and schema builders. The Talk also emphasizes the need to focus on the best developer experience in the present rather than seeking a perfect long-term solution. Additionally, it mentions the future of the Urkel GraphQL client and the reasons for dropping ReScript support. Overall, the Talk provides insights into the current state and future trends of GraphQL development.

Today's talk is about GraphQL State Management and the benefits it offers. Redux and Apollo GraphQL are compared for their state management capabilities, with Apollo Client 3 highlighted as a powerful tool that simplifies front-end development. Data transformations and manipulation in Apollo Client, including type policies and reactive variables, are discussed as key features. The talk concludes by emphasizing the advantages of using Apollo Client for state management and providing access to the presentation materials and newsletter for further updates.

This Talk discusses the challenges of working with data APIs and GraphQL, including standardization, performance, and security. It emphasizes the need to optimize data fetches and push down authorization logic. The concept of externalizing authorization and using a GraphQL engine is explored. The Talk also covers the generation of GraphQL schemas and APIs, as well as the implementation of node-level security. Overall, the focus is on designing and standardizing GraphQL for data APIs while addressing authorization challenges.

This talk introduces the theory and practice of authorization in GraphQL, highlighting the importance of proper authorization in ensuring application functionality and security. Delegating authorization to the business logic layer is a golden rule in GraphQL, ensuring consistency and avoiding duplication of logic. Authorization can be done in the resolver layer, but it is recommended to combine it with filtering at the database level. Abstracting authorization behind an API centralizes logic and makes it easier to manage. Custom directives and permissions fields can reduce the tedium of ensuring correct authorization in every resolver.

This lightning talk explores the use of GraphQL subscriptions with Kafka and Debezium. By adding a message broker like Apache Kafka and a change data capture tool like Debezium to the deployment, issues with multiple service instances and database writes can be resolved. Debezium picks up changes directly from the database and sends CDC event messages to the connected message broker, ensuring that any change in the database will be published to Kafka and received by the service instance. This technology stack can also be used for queries by building a dedicated read model database for the GraphQL API.

In the Schema 1st approach, you can build and deploy a backend only by writing your GraphQL SDL. Connect this to GitHub, and GraphBase takes care of the rest. Once the code is deployed, sign in to GraphBase using your GitHub account and explore the dashboard, schema, and playground. GraphBase offers authentication, authorization, permissions, and custom directives. Connect GraphBase to user-management software and create sign-in and sign-up pages.

Welcome to the talk! As developers, we manage and understand the data that the world runs on. Each individual schema in your infrastructure defines your data in the context of its own domain. The Prisma schema is used to generate migrations and create a mapping between the database and API, enabling type-safe interactions. The GraphQL schema allows clients to safely query the database via the API. By using Prisma and GraphQL Code Generator, you can achieve an end-to-end type-safe environment.

DAST helps prioritize fixing application security issues by identifying discoverable and exploitable vulnerabilities. StackHawk runs active security tests against APIs to ensure safe handling of user input and output. It also implements OWASP top 10 API best practices. The tool can be used locally and in CI/CD pipelines.